从'GLVOID（*）（）{aka void（*）（）}'无效转换为'void（__attribute __（（__ cdecl__））*）（int）'

Question

我无法使用visual studio 2012编译程序甚至代码块我得到这些错误：

error C2664: 'glutTimerFunc' : impossible to convert parameter 2 of 'GLvoid (__cdecl >*)(void)' into 'void (__cdecl *)(int)' 
in both lignes 132, 240, 267 
error C2146: syntaxe error : absence of';' before identifier 'qobj' in ligne 274 

下面是代码：

/***************************************************************************** 
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 <stdio.h>  
#include <stdlib.h>  
#include <math.h> 
#include <GL/glut.h>  
#include <tiff/tiffio.h>  /* 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(&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(&window_display); 
    // le redimensionnement de la fenêtre 
    glutReshapeFunc(&window_reshape); 
    // la gestion des événements clavier 
    glutKeyboardFunc(&window_key); 
    // fonction appelée régulièrement entre deux gestions d´événements 
    glutTimerFunc(latence,&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,&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,&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(); 
} 

Answer 1

的错误与那的glutTimerFunc第二个参数想要一个指针签名void funct(int)而函数的事实代码传递一个没有参数的函数。

它应该是这样的

GLvoid window_timer(int msec) { 

} 

glutTimerFunc(latence,&window_timer,Step);