OpenGL error GL_INVALID_ENUM (0x0500) while glewInit()

问题

I'm new to OpenGL and try to learn OpenGL 4 by following the http://www.openglbook.com tutorial. On page two, we create a simple triangle using shaders. But right after creating the vertex shader, the program crashes. By Debugging, I could find a OpenGL error GL_INVALID_ENUM (0x0500). See code below...

Unfrotunately I couldn't find any solution. Maybe you know sth?

Edit:

So, after searching again for GL_INVALID_ENUM and glewInit(), I found that there are already many posts on other Websites, BUT: Most of them had some typos in their shaders and I definitely don't. On http://www.opengl.org/wiki/OpenGL_Loading_Library i found:

You might still get GL_INVALID_ENUM (depending on the version of GLEW you use), but at least GLEW ignores glGetString(GL_EXTENSIONS) and gets all function pointers.

Some recommend to just ignore the error, but I still can't run the program... Btw, could anyone of you try to run the program? If you had the same error, we'd definitely know it's not a wrong IDE/Project configuration of mine.

Specs:

Windows 8.1 64bit
Intel Core i7-3517U with
Intel HD4000 GPU (OpenGL 4.0.0 Support)
8 GB RAM

IDE:

Eclipse IDE for C/C++ Developers
Version: Kepler Service Release 1
Build id: 20130919-0819
using MinGW Compiler

code:

#include <stdlib.h>
#include <stdio.h>
#include <string>
#define GLEW_STATIC
#include <gl/glew.h>
#include <gl/freeglut.h>


#define WINDOW_TITLE_PREFIX "Chapter 2"

// initialization
int CurrentWidth = 800,
    CurrentHeight = 600,
    WindowHandle = 0;

// timer
unsigned FrameCount = 0;

// chapter2 buffer object.........................
GLuint VertexShaderId,
       FragmentShaderId,
       ProgramId,
       VaoId,
       VboId,
       ColorBufferId;

const GLchar *VertexShader = {
        "#version 400\n"\

        "layout(location=0) in vec4 in_Position;\n"\
        "layout(location=1) in vec4 in_Color;\n"\
        "out vec4 ex_Color;\n"\

        "void main(void) {\n"\
        "    gl_Position = in_Position;\n"\
        "    ex_Color = in_Color;\n"\
        "}\n"
};
const GLchar *FragmentShader = {
        "#version 400\n"\

        "in vec4 ex_Color;\n"\
        "out vec4 out_Color;\n"\

        "void main(void) {\n"\
        "    out_Color = ex_Color;\n"\
        "}\n"
};
//................................chapter2 buffer object


// initialization
void Initialize(int,char*[]);
void InitWindow(int,char*[]);
void ResizeFunction(int,int);
void RenderFunction(void);

//timer
void TimerFunction(int);
void IdleFunction(void);

// chapter2 buffer object
void Cleanup(void);
void CreateVBO(void);
void DestroyVBO(void);
void CreateShaders(void);
void DestroyShaders(void);


int main(int argc, char *argv[]) {
    fprintf(stdout,"Starting OpenGL programm...\n");

    Initialize(argc,argv);
    glutMainLoop();

    fprintf(stdout,"Program terminated.\n");
    exit(EXIT_SUCCESS);
}


void Initialize(int argc, char *argv[]) {
    GLenum GlewInitResult; //glew

    InitWindow(argc,argv);

    //glew...........
    GlewInitResult = glewInit();

    if(GLEW_OK != GlewInitResult) {
        fprintf(stderr,
                "ERROR: %s\n",
                glewGetErrorString(GlewInitResult) );
        exit(EXIT_FAILURE);
    }
    //.................glew.

    fprintf(stdout,
            "INFO: OpenGL Version: %s\n",
            glGetString(GL_VERSION) );

    //chapter2 buffer objects
    CreateShaders();
    CreateVBO();



    glClearColor(0.0f,0.0f,0.0f,0.0f);
}

void InitWindow(int argc, char *argv[]) {
    glutInit(&argc,argv); // always the first function to call!!!

    glutInitContextVersion(4,0);
    glutInitContextFlags(GLUT_FORWARD_COMPATIBLE);
    glutInitContextProfile(GLUT_CORE_PROFILE);

    glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,
                  GLUT_ACTION_GLUTMAINLOOP_RETURNS);

    glutInitWindowSize(CurrentWidth,CurrentHeight);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);

    WindowHandle = glutCreateWindow(WINDOW_TITLE_PREFIX);

    if(WindowHandle < 1) {
        fprintf(stderr,
                "ERROR: Could not create a new rendering window.\n");
        exit(EXIT_FAILURE);
    }

    glutReshapeFunc(ResizeFunction);
    glutDisplayFunc(RenderFunction);

    //timer
    glutIdleFunc(IdleFunction);
    glutTimerFunc(0,TimerFunction,0);

    //chapter2 buffer object
    glutCloseFunc(Cleanup);
}

void ResizeFunction(int Width, int Height) {
    CurrentWidth = Width;
    CurrentHeight = Height;
    glViewport(0,0,CurrentWidth,CurrentHeight);
}

void RenderFunction() {
    //timer
    ++FrameCount;

    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

    //chapter2 buffer object
    glDrawArrays(GL_TRIANGLES,0,3);

    glutSwapBuffers();
    glutPostRedisplay();
}

//timer.................................
void IdleFunction() {
    glutPostRedisplay();
}

void TimerFunction(int Value) {
    if(0 != Value) {
        char *TempString = (char*) malloc(512 + strlen(WINDOW_TITLE_PREFIX));

        sprintf(TempString,
                "%s: %d Frames Per Second @ %d x %d",
                WINDOW_TITLE_PREFIX,
                FrameCount * 4,
                CurrentWidth,
                CurrentHeight );

        glutSetWindowTitle(TempString);
        free(TempString);
    }
    FrameCount = 0;
    glutTimerFunc(250,TimerFunction,1);
}
//...........................................timer

//chapter2 buffer object..................................
void Cleanup() {
    DestroyShaders();
    DestroyVBO();
}

void CreateVBO() {
    GLfloat Vertices[] = {
            -0.8f, -0.8f,  0.0f, 1.0f,
             0.0f,  0.8f,  0.0f, 1.0f,
             0.8f, -0.8f,  0.0f, 1.0f
    };

    GLfloat Colors[] = {
            1.0f, 0.0f, 0.0f, 1.0f,
            0.0f, 1.0f, 0.0f, 1.0f,
            0.0f, 0.0f, 1.0f, 1.0f
    };

    GLenum ErrorCheckValue = glGetError();

    glGenVertexArrays(1,&VaoId);
    glBindVertexArray(VaoId);

    glGenBuffers(1,&VboId);
    glBindBuffer(GL_ARRAY_BUFFER, VboId);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Vertices), Vertices, GL_STATIC_DRAW);
    glVertexAttribPointer(0,4,GL_FLOAT, GL_FALSE, 0,0);
    glEnableVertexAttribArray(0);

    glGenBuffers(1,&ColorBufferId);
    glBindBuffer(GL_ARRAY_BUFFER, ColorBufferId);
    glBufferData(GL_ARRAY_BUFFER, sizeof(Colors), Colors, GL_STATIC_DRAW);
    glVertexAttribPointer(1,4,GL_FLOAT, GL_FALSE, 0,0);
    glEnableVertexAttribArray(1);

    ErrorCheckValue = glGetError();
    if(ErrorCheckValue != GL_NO_ERROR) {
        fprintf(stderr,
                "ERROR: Could not create a VBO: %s \n",
                gluErrorString(ErrorCheckValue) );
        exit(-1);
    }
}

void DestroyVBO() {
    GLenum ErrorCheckValue = glGetError();

    glDisableVertexAttribArray(1);
    glDisableVertexAttribArray(0);

    glBindBuffer(GL_ARRAY_BUFFER,0);

    glDeleteBuffers(1, &ColorBufferId);
    glDeleteBuffers(1, &VboId);

    glBindVertexArray(0);
    glDeleteVertexArrays(1,&VaoId);

    ErrorCheckValue = glGetError();
    if(ErrorCheckValue != GL_NO_ERROR) {
        fprintf(stderr,
                "ERROR: Could not destroy the VBO: %s \n",
                gluErrorString(ErrorCheckValue) );
        exit(-1);
    }
}

void CreateShaders() {
    GLenum ErrorCheckValue = glGetError();

    VertexShaderId = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(VertexShaderId,1,&VertexShader,NULL);
    glCompileShader(VertexShaderId);

    FragmentShaderId = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(FragmentShaderId,1,&FragmentShader,NULL);
    glCompileShader(FragmentShaderId);

    ProgramId = glCreateProgram();
        glAttachShader(ProgramId, VertexShaderId);
        glAttachShader(ProgramId, FragmentShaderId);
    glLinkProgram(ProgramId);

    if(glIsProgram(ProgramId) != GL_TRUE) {
            fprintf(stderr,
                    "ERROR: This is no GL program!\n");
            exit(-1);
        }
    glUseProgram(ProgramId);

    ErrorCheckValue = glGetError();
    if(ErrorCheckValue != GL_NO_ERROR) {
        fprintf(stderr,
                "ERROR: Could not create the shaders: %s \n",
                gluErrorString(ErrorCheckValue) );
        exit(-1);
    }
}

void DestroyShaders() {
    GLenum ErrorCheckValue = glGetError();

    glUseProgram(0);

    glDetachShader(ProgramId, VertexShaderId);
    glDetachShader(ProgramId, FragmentShaderId);

    glDeleteShader(FragmentShaderId);
    glDeleteShader(VertexShaderId);

    glDeleteProgram(ProgramId);

    ErrorCheckValue = glGetError();
    if(ErrorCheckValue != GL_NO_ERROR) {
        fprintf(stderr,
                "ERROR: Could not destroy the VBO: %s \n",
                gluErrorString(ErrorCheckValue) );
        exit(-1);
    }
}

回答1:

I could finally solve the problem: First of all, I did severel minor changes, so I can not tell you, if it was just one change or the sum of all, what solved it.

delete the glu library. I had to link this library to use gluErrorString(...). Replace this function with glewGetErrorString(...). Now you don't need the glu library anymore.
probably the reason for the error: Delete glutInitContextVersion(4,0);. I can't tell you really why - probably glew doesn't support the new OpenGL 4 functions.

That's it. I hope this helps (I found the same problem on several other Websites)! And thanks for your advices :)

来源：https://stackoverflow.com/questions/19453439/opengl-error-gl-invalid-enum-0x0500-while-glewinit

标签

c++

opengl

enums

crash

glew