glewInit() non riesce su macOS

Question

Quindi ho un pezzo di codice che gira bene su Ubuntu, ma non riesce a farlo su xcode o tramite terminale. Sto cercando di eseguirlo su xcode, ma non riesce su main con:

"Uso di identificatore non dichiarato glewInit; intendevi intenderlo?" "Troppo pochi argomenti per chiamare la chiamata, 2 previsti, hanno 0"

Il codice è lungo è stato scritto dal mio professore e funziona su ubuntus. Ma con gli errori, sto pensando che le ragioni siano ... beh, l'identificatore non classificato, l'assenza è mancante. Così, dopo googling ho capito che glewInit è parte della libreria Glew -> così ho scaricato il codice e installato sulla mia macchina con la seguente:

fanno sudo -s make install

che erano con successo installato nel mio/usr/include/GL. Ora, quando digito in xcode #include o semplicemente #include, il compilatore lancia che glew.h non viene trovato (sebbene io possa vedere il file da solo in usr/include/GL).

Ecco il codice:

#include "include/Angel.h" 

// The rotation around z axis 
GLfloat Theta = 0.0; // Angle (in degrees) 
GLfloat step = 0.01; // Incremental 
GLuint locTheta; 
enum { CW = 0, CCW = 1}; 
int direction = CW; // Direction 

//Scale along x and y axes 
GLfloat ScaleFactor[2] = {1.0, 1.0}; 
GLuint locScale; 

const int NumPoints = 4; 
void init(); 
void display(void); 
void reshape(GLsizei w, GLsizei h); 
void keyboard(unsigned char key, int x, int y); 
void mouse(int button, int state, int x, int y); 
void idle(void); 
//---------------------------------------------------------------------------- 

// OpenGL initialization 
void init() 
{ 
    // Vertices of a unit square centered at origin, sides aligned with axes 
    vec4 points[] = { 
     vec4(-0.5, -0.5, 0, 1.0), //v1 
     vec4( 0.5, -0.5, 0, 1.0), //v2 
     vec4(-0.5, 0.5, 0, 1.0), //v3 
     vec4( 0.5, 0.5, 0, 1.0) //v4 
    }; 

    // RGBA colors 
    vec4 colors[] = { 
     vec4(1.0, 0.0, 0.0, 1.0), // red 
     vec4(0.0, 1.0, 0.0, 1.0), // green 
     vec4(0.0, 1.0, 0.0, 1.0), // green 
     vec4(0.0, 0.0, 1.0, 1.0), // blue 
    }; 

    // Create and initialize a buffer object 
    GLuint buffer; 
    glGenBuffers(1, &buffer); 
    glBindBuffer(GL_ARRAY_BUFFER, buffer); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(points) + sizeof(colors), NULL, GL_STATIC_DRAW); 
    glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(points), points); 
    glBufferSubData(GL_ARRAY_BUFFER, sizeof(points), sizeof(colors), colors); 

    // Load shaders and use the resulting shader program 
    GLuint program = InitShader("vshader_rot.glsl", "fshader_rot.glsl"); 
    glUseProgram(program); 

    // set up vertex arrays 
    GLuint vPosition = glGetAttribLocation(program, "vPosition"); 
    glEnableVertexAttribArray(vPosition); 
    glVertexAttribPointer(vPosition, 4, GL_FLOAT, GL_FALSE, 0, 
       BUFFER_OFFSET(0)); 

    GLuint vColor = glGetAttribLocation(program, "vColor"); 
    glEnableVertexAttribArray(vColor); 
    glVertexAttribPointer(vColor, 4, GL_FLOAT, GL_FALSE, 0, 
       BUFFER_OFFSET(sizeof(points))); 

    // The location of shader uniform variables 
    locTheta = glGetUniformLocation(program, "theta"); 
    locScale = glGetUniformLocation(program, "scale"); 

    glClearColor(1.0, 1.0, 1.0, 1.0); 
} 

//---------------------------------------------------------------------------- 

void display(void) 
{ 
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 

    glUniform1f(locTheta, Theta); 
    glUniform2fv(locScale, 1, ScaleFactor); 

    glDrawArrays(GL_TRIANGLE_STRIP, 0, NumPoints); 

    glutSwapBuffers(); 
} 

//---------------------------------------------------------------------------- 
void reshape(GLsizei w, GLsizei h) 
{ 
    glViewport(0, 0, w, h); 

    // Scale the square to avoid stretching 
    if (w > h) ScaleFactor[0] = (float)h/w; 
    if (w < h) ScaleFactor[1] = (float)w/h; 
} 

//---------------------------------------------------------------------------- 

void keyboard(unsigned char key, int x, int y) 
{ 
    switch(key) { 
    case 033: // Escape Key 
    case 'q': case 'Q': 
     exit(EXIT_SUCCESS); 
     break; 
    } 
} 

//---------------------------------------------------------------------------- 

void mouse(int button, int state, int x, int y) 
{ 
    if (state == GLUT_DOWN) { 
     switch(button) 
     { 
     case GLUT_LEFT_BUTTON:  
      direction = CCW; 
      break; 
     case GLUT_RIGHT_BUTTON: 
      direction = CW; 
      break; 
     } 
    } 
} 

//---------------------------------------------------------------------------- 

void idle(void) 
{ 
    // Animate the rotation 
    if (direction == CW)  
     Theta += step; 
    else 
     Theta -= step; 

    if (Theta > 360.0) { 
     Theta -= 360.0; 
    } 

    glutPostRedisplay(); 
} 

//---------------------------------------------------------------------------- 

int main(int argc, char **argv) 
{ 
    glutInit(&argc, argv); 
    glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH); 
    glutInitWindowSize(512, 512); 
    glutCreateWindow("Rotating Color Square"); 

    glewInit(); 
    init(); 

    glutDisplayFunc(display); 
    glutReshapeFunc(reshape); 
    glutKeyboardFunc(keyboard); 
    glutMouseFunc(mouse); 
    glutIdleFunc(idle); 

    glutMainLoop(); 
    return 0; 
} 

ho Lion 10.7.4 e xCode 4.2.1

Answer 1

glewInit() chiamata (e la include, ovviamente) non è necessario su MacOS, in modo potresti semplicemente escluderlo in questo modo:

#ifndef __APPLE__ 
glewInit(); 
#endif 

Lo stesso con include.

Ora con i simboli non risolti. È necessario includere le intestazioni GL nativi di MacOSX:

#ifdef __APPLE__ 
# include <OpenGL/gl.h> 
# include <OpenGL/glext.h> 
#else /// your stuff for linux 
# include "GL/GL.h" 
.... whatever 
#endif 

OpenGL è una tecnologia di base per OSX, non una "estensione", come in Linux/X Window. Quindi, includi semplicemente il framework OpenGL e GLUT nel tuo progetto XCode e spero che dovrebbe costruirlo e funzionare.