title: Invalid conversion from 'GLvoid (*)() {aka void (*)()}' to 'void (__attribute__((__cdecl__)) *)(int)'
body: <p>I can't compile a program with visual studio 2012 or even codeblocks I get these errors:</p>
  
  <pre><code>error C2664: 'glutTimerFunc' : impossible to convert parameter 2 of 'GLvoid (__cdecl &gt;*)(void)' into 'void (__cdecl *)(int)'
  in both lignes 132, 240, 267
  error C2146: syntaxe error : absence of';' before identifier 'qobj' in ligne 274
  </code></pre>
  
  <p>Here is the code:</p>
  
  <pre><code>/*****************************************************************************
  File: TD5-avatar-modele.c
  
  Informatique Graphique IG1
  Master d'informatique
  Christian Jacquemin, Université Paris 11
  
  Copyright (C) 2004 University Paris 11 
  This file is provided without support, instruction, or implied
  warranty of any kind.  University Paris 11 makes no guarantee of its
  fitness for a particular purpose and is not liable under any
  circumstances for any damages or loss whatsoever arising from the use
  or inability to use this file or items derived from it.
  ******************************************************************************/
  
  #include &lt;stdio.h&gt;      
  #include &lt;stdlib.h&gt;     
  #include &lt;math.h&gt;
  #include &lt;GL/glut.h&gt;    
  #include &lt;tiff/tiffio.h&gt;     /* Sam Leffler's libtiff library. */
  int writetiff(char *filename, char *description,
            int x, int y, int width, int height, int compression);
  
  #define    windowWidth 300
  #define    windowHeight 300
  
  #define RED   0
  #define GREEN 0
  #define BLUE  0
  #define ALPHA 1
  
  #define true  1
  #define false 0
  
  #define KEY_ESC 27
  
  #define PI 3.1415926535898
  
  #define position_Ini                   -60.0
  
  float t = 0.f;
  float delta = 10.f;
  float k = 0.001f;
  float K = 0.002f;
  int IdleRunning = true;
  int TraceEcran = false;
  int RangFichierStockage = 0;
  float position = position_Ini;
  
  int  Ma_Tete;
  int  Mon_Tronc;
  int  Mon_Bras;
  int  Mon_AvantBras;
  int  Ma_Cuisse;
  int  Mon_Mollet;
  int  Mon_Repere;
  
  enum lateralite{ Gauche = 0, Droit };
  
  float angle_Bras[2];
  float angle_AvantBras[2];
  float angle_Cuisse[2];
  float angle_Mollet[2];
  
  float angle_Bras_Ini[2] = {-30.0, 15.0};
  float angle_AvantBras_Ini[2] = {0.0, 15.0};
  float angle_Cuisse_Ini[2] = {20.0, -20.0};
  float angle_Mollet_Ini[2] = {0.0, -20.0};
  
  float amplitude_Bras;
  float amplitude_AvantBras;
  float amplitude_Cuisse;
  float amplitude_Mollet;
  float med_Bras;
  float med_AvantBras;
  float med_Cuisse;
  float med_Mollet;
  
  static GLfloat mat_specular[] = { 1.0 , 1.0 , 1.0 , 1.0 };
  static GLfloat mat_ambientanddiffuse[] = { 0.4, 0.4 , 0.0 , 1.0 };
  static GLfloat mat_shininess[] = { 20.0};
  
  static GLfloat light_position0[] = { 15.0 , 15.0 , 15.0 , 0.0 };
  static GLfloat light_position1[] = { 15.0 , 15.0 , -15.0 , 0.0 };
  
  static GLfloat ambient_light0[] = { 0.0 , 0.0 , 0.0 , 0.0 };
  static GLfloat diffuse_light0[] = { 0.7 , 0.7 , 0.7 , 1.0 };
  static GLfloat specular_light0[] = { 0.1 , 0.1 , 0.1 , 0.1 };
  
  static GLfloat ambient_light1[] = { 0.50 , 0.50 , 0.50 , 1.0 };
  static GLfloat diffuse_light1[] = { 0.5 , 1.0 , 1.0 , 1.0 };
  static GLfloat specular_light1[] = { 0.5 , 1.0 , 1.0 , 1.0 };
  
  int Step = 0;
  int latence =4;
  
  void init_scene();
  void render_scene();
  void init_angles();
  GLvoid initGL();
  GLvoid window_display();
  GLvoid window_reshape(GLsizei width, GLsizei height); 
  GLvoid window_key(unsigned char key, int x, int y); 
  GLvoid window_timer(); 
  void Faire_Composantes();
  void Dessine_Repere();
  
  int main(int argc, char **argv) 
  {  
    // initialisation  des paramètres de GLUT en fonction
    // des arguments sur la ligne de commande
    glutInit(&amp;argc, argv);
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH);
  
    // définition et création de la fenêtre graphique
    glutInitWindowSize(windowWidth,windowHeight);
    glutInitWindowPosition(0, 0);
    glutCreateWindow("Avatar animé");
  
    // initialisation de OpenGL et de la scène
    initGL();  
    init_scene();
  
    // choix des procédures de callback pour 
    // le tracé graphique
    glutDisplayFunc(&amp;window_display);
    // le redimensionnement de la fenêtre
    glutReshapeFunc(&amp;window_reshape);
    // la gestion des événements clavier
    glutKeyboardFunc(&amp;window_key);
    // fonction appelée régulièrement entre deux gestions d´événements
    glutTimerFunc(latence,&amp;window_timer,Step);
  
    // la boucle prinicipale de gestion des événements utilisateur
    glutMainLoop();  
  
    return 1;
  }
  
  // initialisation du fond de la fenêtre graphique : noir opaque
  
  GLvoid initGL() 
  {
    // initialisation de l´éclairement
  
    // définition de deux source lumineuses
    glLightfv(GL_LIGHT0, GL_AMBIENT, ambient_light0);
    glLightfv(GL_LIGHT0, GL_DIFFUSE, diffuse_light0);
    glLightfv(GL_LIGHT0, GL_SPECULAR, specular_light0);
    glLightfv(GL_LIGHT1, GL_AMBIENT, ambient_light1);
    glLightfv(GL_LIGHT1, GL_DIFFUSE, diffuse_light1);
    glLightfv(GL_LIGHT1, GL_SPECULAR, specular_light1);
    glLightfv(GL_LIGHT0, GL_POSITION, light_position0);
    glLightfv(GL_LIGHT1, GL_POSITION, light_position1);
  
    // activation de l´éclairement
    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_LIGHT1);
  
    // propriétés matérielles des objets
    // glMaterialfv(GL_FRONT, GL_AMBIENT_AND_DIFFUSE, mat_ambientanddiffuse);
    // glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    // glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
    glShadeModel( GL_SMOOTH );
    glEnable(GL_COLOR_MATERIAL);
  
    // initialisation du fond
    glClearColor(RED, GREEN, BLUE, ALPHA);        
    // z-buffer
    glEnable(GL_DEPTH_TEST);
  }
  
  void init_scene()
  {
    // initialise des display lists des composantes cylindriques du corps
    Faire_Composantes();
  
    amplitude_Bras 
      = .5 * (angle_Bras_Ini[ Droit ] - angle_Bras_Ini[ Gauche ]);
    amplitude_AvantBras 
      = .5 * (angle_AvantBras_Ini[ Droit ] - angle_AvantBras_Ini[ Gauche ]);
    amplitude_Cuisse 
      = .5 * (angle_Cuisse_Ini[ Droit ] - angle_Cuisse_Ini[ Gauche ]);
    amplitude_Mollet 
      = .5 * (angle_Mollet_Ini[ Droit ] - angle_Mollet_Ini[ Gauche ]);
    med_Bras 
      = .5 * (angle_Bras_Ini[ Droit ] + angle_Bras_Ini[ Gauche ]);
    med_AvantBras 
      = .5 * (angle_AvantBras_Ini[ Droit ] + angle_AvantBras_Ini[ Gauche ]);
    med_Cuisse 
      = .5 * (angle_Cuisse_Ini[ Droit ] + angle_Cuisse_Ini[ Gauche ]);
    med_Mollet 
      = .5 * (angle_Mollet_Ini[ Droit ] + angle_Mollet_Ini[ Gauche ]);
  }
  
  // fonction de call-back pour l´affichage dans la fenêtre
  
  GLvoid window_display()
  {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
    glLoadIdentity();
  
    render_scene();
  
    // trace la scène grapnique qui vient juste d'être définie
    glFlush();
  }
  
  // fonction de call-back pour le redimensionnement de la fenêtre
  
  GLvoid window_reshape(GLsizei width, GLsizei height)
  {  
    glViewport(0, 0, width, height);
  
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glOrtho(-20, 20, -20, 20, -1000, 1000);
    // glFrustum(-20, 20, -20, 20, 10, 1000);
    // glScalef(10, 10, 10);
  
    // toutes les transformations suivantes s´appliquent au modèle de vue 
    glMatrixMode(GL_MODELVIEW);
  }
  
  // fonction de call-back pour la gestion des événements clavier
  
  GLvoid window_key(unsigned char key, int x, int y) 
  {  
    switch (key) {    
    case KEY_ESC:  
      exit(1);                    
      break; 
    case ' ':  
      if (IdleRunning) {
        glutTimerFunc(latence,NULL,Step);
        IdleRunning = false;
      } 
      else {
        glutTimerFunc(latence,&amp;window_timer,Step);
        IdleRunning = true;
      }
      break; 
    case '+':  
      delta *= 1.01;
      break; 
    case '-':  
      delta /= 1.01;
      break; 
    default:
      printf ("La touche %d n´est pas active.\n", key);
      break;
    }     
  }
  
  // fonction de call-back appelée régulièrement
  
  GLvoid window_timer() 
  {
    // On effecture une variation des angles de chaque membre
    // de l'amplitude associée et de la position médiane
    // ********* A FAIRE **************
  
    // On déplace la position de l'avatar pour qu'il avance
    // ********* A FAIRE **************
  
    glutTimerFunc(latence,&amp;window_timer,++Step);
  
    glutPostRedisplay();
  }
  
  // un cylindre
  void Faire_Composantes() {
    GLUquadricObj* GLAPIENTRY qobj;
  
    // attribution des indentificateurs de display lists
    Ma_Tete =  glGenLists(6);
    Mon_Tronc = Ma_Tete + 1;
    Mon_Bras = Ma_Tete + 2;
    Mon_AvantBras = Ma_Tete + 3;
    Ma_Cuisse = Ma_Tete + 4;
    Mon_Mollet = Ma_Tete + 5;
  
    // compilation de la display list de la sphère
    // ********* A FAIRE **************
  
    // allocation d´une description de quadrique
    qobj = gluNewQuadric();
    // la quadrique est pleine 
    gluQuadricDrawStyle(qobj, GLU_FILL); 
    // les ombrages, s´il y en a, sont doux
    gluQuadricNormals(qobj, GLU_SMOOTH);
  
    // compilation des display lists des cylindres
    // ********* A FAIRE **************
  }
  
  void  Dessine_Repere() {
    glNewList(Mon_Repere, GL_COMPILE);
      glBegin(GL_LINES);
        glColor3f(1.0, 0.0, 0.0);
        glVertex3f(-10 , 0 , 0);
        glVertex3f(10 , 0 , 0);
      glEnd();
      glBegin(GL_LINES);
        glColor3f(0.0, 1.0, 0.0);
        glVertex3f(0 , -10 , 0);
        glVertex3f(0 , 10 , 0);
      glEnd();
      glPointSize( 10.0 );
      glBegin(GL_POINTS);
        glColor3f(1.0, 1.0, 1.0);
        glVertex3f(10.0 , 0 , 0);
      glEnd();
      glBegin(GL_POINTS);
        glColor3f(1.0, 1.0, 1.0);
        glVertex3f(0 , 10.0 , 0);
      glEnd();
    glEndList();
  }
  
  void render_scene()
  {
    // rotation de 90 degres autour de Ox pour mettre l'axe Oz 
    // vertical comme sur la figure
    glRotatef(-90, 1, 0, 0);
  
    // rotation de 160 degres autour de l'axe Oz pour faire
    // avancer l'avatar vers le spectateur
    glRotatef(-160, 0, 0, 1);
  
    // rotation de 25 degres autour de la bissectrice de $Oy$ pour
    // voir la figure en perspective
    // glRotatef(25, 0, 1, 0);
  
    // déplacement horizontal selon l´axe Oy pour donner 
    // une impression de déplacement horizontal accompagnant
    // la marche
    glTranslatef( 0, position, 0);
  
    // tracé du tronc, aucune transformation n´est
    // requise
    glColor3f(1.0, 1.0, 1.0);
    glCallList(Mon_Tronc);
  
    // tracé de la tête avec une translation positive
    // selon Oz pour la placer au-dessus du tronc
    // les appels à glPushMatrix et glPopMatrix servent 
    // à sauvegarder et restaurer le contexte graphique
    // ********* A FAIRE **************
  
    // tracé de la cuisse droite avec une translation vers
    // la droite et une rotation de 180° autour de Ox
    // pour l´orienter vers le bas
    // ********* A FAIRE **************
  
    // pour tracer le mollet, on reste dans le même
    // contexte graphique et on translate de
    // +5 selon Oz afin de mettre le repère au niveau
    // du genou
    // ********* A FAIRE **************
  
    // cuisse et mollet gauches
    // seule la translation initiale change
    // ********* A FAIRE **************
  
    // tracé du bras droit avec une translation vers
    // la droite et vers le haut composée avec une 
    // rotation de 180° autour de Ox pour l´orienter
    // vers le bas
    // ********* A FAIRE **************
  
    // pour tracer l´avant-bras, on reste dans le même
    // contexte graphique et on translate de
    // +5 selon Oz afin de mettre le repère au niveau
    // du coude
    // ********* A FAIRE **************
  
    // bras et avant-bras gauches
    // seule la translation initiale change
    // ********* A FAIRE **************
  
    // permutation des buffers lorsque le tracé est achevé
    glutSwapBuffers();
  }
  </code></pre>