why glunurbscallback(theNurb, GLU_NURBS_VERTEX, (_GLUfuncptr)vertexCallback) can not get data under X64 procedure,but work under X86?

Question

I want to get data from nurbs surface.So i use the gluNurbsSurface() function in glu to read a nurbs surface and the gluNurbsCallback() to get the data on the surface.Why it work on X86 procedure but failure on X64 procedure?

Here is my code:

/*Headers use freeglut X86 or X64*/
#include <GL/glut.h>
#include<GLFW/glfw3.h>
#include <stdlib.h>
#include <stdio.h>

#ifdef GLU_VERSION_1_3

#ifndef CALLBACK
#define CALLBACK
#endif

GLfloat ctlpoints[4][4][3];
int showPoints = 0;

GLUnurbsObj *theNurb;


void init_surface(void)
{
int u, v;
for (u = 0; u < 4; u++) {
    for (v = 0; v < 4; v++) {
        ctlpoints[u][v][0] = 2.0*((GLfloat)u - 1.5);
        ctlpoints[u][v][1] = 2.0*((GLfloat)v - 1.5);

        if ((u == 1 || u == 2) && (v == 1 || v == 2))
            ctlpoints[u][v][2] = 3.0;
        else
            ctlpoints[u][v][2] = -3.0;
        }
    }
}

static void CALLBACK nurbsError(GLenum errorCode)
{
    const GLubyte *estring;

    estring = gluErrorString(errorCode);
    fprintf(stderr, "Nurbs Error: %s\n", estring);
    exit(0);
}

static void CALLBACK beginCallback(GLenum whichType)
{
    glBegin(whichType);  /*  resubmit rendering directive  */
    printf("glBegin(");
    switch (whichType) {  /*  print diagnostic message  */
    case GL_LINES:
        printf("GL_LINES)\n");
        break;
    case GL_LINE_LOOP:
        printf("GL_LINE_LOOP)\n");
        break;
    case GL_LINE_STRIP:
        printf("GL_LINE_STRIP)\n");
        break;
    case GL_TRIANGLES:
        printf("GL_TRIANGLES)\n");
        break;
    case GL_TRIANGLE_STRIP:
        printf("GL_TRIANGLE_STRIP)\n");
        break;
    case GL_TRIANGLE_FAN:
        printf("GL_TRIANGLE_FAN)\n");
        break;
    case GL_QUADS:
        printf("GL_QUADS)\n");
        break;
    case GL_QUAD_STRIP:
        printf("GL_QUAD_STRIP)\n");
        break;
    case GL_POLYGON:
        printf("GL_POLYGON)\n");
        break;
    default:
        break;
    }
}

static void CALLBACK endCallback()
{
    glEnd();  /*  resubmit rendering directive  */
    printf("glEnd()\n");
}

static void CALLBACK vertexCallback(GLfloat *vertex)
{
    glVertex3fv(vertex);  /*  resubmit rendering directive  */
    printf("glVertex3f (%5.3f, %5.3f, %5.3f)\n",
        vertex[0], vertex[1], vertex[2]);
}

static void CALLBACK normalCallback(GLfloat *normal)
{
    glNormal3fv(normal);  /*  resubmit rendering directive  */
    printf("glNormal3f (%5.3f, %5.3f, %5.3f)\n",
        normal[0], normal[1], normal[2]);
}

/*init light and nurbs surface*/
void init(void)
{
    GLfloat mat_diffuse[] = { 0.7, 0.7, 0.7, 1.0 };
    GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
    GLfloat mat_shininess[] = { 100.0 };

    glClearColor(0.0, 0.0, 0.0, 0.0);
    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);

    glEnable(GL_LIGHTING);
    glEnable(GL_LIGHT0);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_AUTO_NORMAL);
    glEnable(GL_NORMALIZE);

    init_surface();

    theNurb = gluNewNurbsRenderer();
    gluNurbsProperty(theNurb, GLU_NURBS_MODE, GLU_NURBS_TESSELLATOR);
    gluNurbsProperty(theNurb, GLU_SAMPLING_TOLERANCE, 25.0);
    gluNurbsProperty(theNurb, GLU_DISPLAY_MODE, GLU_FILL);
    gluNurbsCallback(theNurb, GLU_NURBS_BEGIN, (_GLUfuncptr)beginCallback);
    gluNurbsCallback(theNurb, GLU_NURBS_VERTEX, (_GLUfuncptr)vertexCallback);
    gluNurbsCallback(theNurb, GLU_NURBS_NORMAL, (_GLUfuncptr)normalCallback);
    gluNurbsCallback(theNurb, GLU_NURBS_END, (_GLUfuncptr)endCallback);
    gluNurbsCallback(theNurb, GLU_ERROR, (_GLUfuncptr)nurbsError);
}

/*display nurbs*/
void display(void)
{
    GLfloat knots[8] = { 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0 };
    int i, j;
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    glPushMatrix();
    glRotatef(330.0, 1., 0., 0.);
    glScalef(0.5, 0.5, 0.5);

    gluBeginSurface(theNurb);
    gluNurbsSurface(theNurb,
        8, knots, 8, knots,
        4 * 3, 3, &ctlpoints[0][0][0],
        4, 4, GL_MAP2_VERTEX_3);
    gluEndSurface(theNurb);

    if (showPoints) {
        glPointSize(5.0);
        glDisable(GL_LIGHTING);
        glColor3f(1.0, 1.0, 0.0);
        glBegin(GL_POINTS);
        for (i = 0; i < 4; i++) {
            for (j = 0; j < 4; j++) {
                glVertex3f(ctlpoints[i][j][0],
                    ctlpoints[i][j][1], ctlpoints[i][j][2]);
            }
        }
        glEnd();
        glEnable(GL_LIGHTING);
    }
    glPopMatrix();
    glFlush();
}

void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(45.0, (GLdouble)w / (GLdouble)h, 3.0, 8.0);
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glTranslatef(0.0, 0.0, -5.0);
}

void keyboard(unsigned char key, int x, int y)
{
    switch (key) {
    case 'c':
    case 'C':
        showPoints = !showPoints;
        glutPostRedisplay();
        break;
    case 27:
        exit(0);
        break;
    default:
        break;
        }
}

int main(int argc, char** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB | GLUT_DEPTH);
    glutInitWindowSize(500, 500);
    glutInitWindowPosition(100, 100);
    glutCreateWindow(argv[0]);
    init();
    glutReshapeFunc(reshape);
    glutDisplayFunc(display);
    glutKeyboardFunc(keyboard);
    glutMainLoop();
    return 0;
}

I ues freeglut as the opengl tool,it is compiled on X64 and X86 platform,I put the dlls and libs in the corresponding locations.

The question is i can not get the data from such procedure on X64,but the nurbs surface can be drawn.On X86,there is not such problem,data and surface will be got and drawn,what is the reason?

Do i need to rebuild opengl from mesa to get glu toolkits to make it work on X64 platform? Or some other useful ways?

i hope gluNurbsCallback() can work on X64 procedure