glewInit() fehlgeschlagen, OpenGL App

Question

Ich versuche eine OpenGL App mit glew/glfw zu erstellen. Ich habe die Binärdateien heruntergeladen, sie in den Stamm meines Ordners gestellt, die Pfade zu den include- und lib-Verzeichnissen hinzugefügt und meinem Projekt gesagt, dass es glew32.lib, GLFW.lib und opengl32.lib benötigt.

Ich habe sogar glew32.lib in das Stammverzeichnis kopiert, weil mein Projekt es nicht sehen konnte.

Ich muss alle Abhängigkeiten im Projektverzeichnis behalten, da ich das verteilen werde. Ich bin ratlos.

Nun, wenn ich mein Programm ausführen, schlägt es bei glewInit()

Das ist meine Umsetzung so weit ist:

#include "Common.h" 

GameEngine::GameEngine() 
{ 
    InitWithSize(1024, 768); 
    InitInput(); 
} 

void GameEngine::InitWithSize(int _width, int _height) 
{ 
    try { 
     // Initialise GLFW 
     if(!glfwInit()) 
      throw std::exception("Failed to initialize GLFW\n"); 

     //glfwOpenWindowHint(GLFW_FSAA_SAMPLES, 4); 
     glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 3); 
     glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 3); 
     glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); 

     // Open a window and create its OpenGL context 
     if(!glfwOpenWindow(_width, _height, 0,0,0,0, 32,0, GLFW_WINDOW)) 
      throw std::exception("Failed to initialize GLFW\n"); 


     glfwSetWindowTitle("Tutorial 01"); 

     // Initialize GLEW 
     if (glewInit() != GLEW_OK) 
      throw std::exception("Failed to initialize GLEW\n"); 


    } catch (std::system_error const& err) { 
     fprintf(stdout, "System Error: %s", err.what()); 
     glfwTerminate(); // Free glfw if it has been allocated 
     // Try Again 
     this->InitWithSize(_width, _height); 
    } catch(std::exception const& err) { 
     fprintf(stdout, "Exception Found: %s", err.what()); 
    } catch (...) { 
     fprintf(stdout,"Unknown Exception Occurred\n"); 
    } 
} 

void GameEngine::InitInput() 
{ 
     // Ensure we can capture the escape key being pressed below 
     glfwEnable(GLFW_STICKY_KEYS); 
} 

void GameEngine::StartGameLoop() 
{ 
    do{ 
      // Draw nothing, see you in tutorial 2 ! 

      // Swap buffers 
      glfwSwapBuffers(); 

     } // Check if the ESC key was pressed or the window was closed 
     while(glfwGetKey(GLFW_KEY_ESC) != GLFW_PRESS && 
      glfwGetWindowParam(GLFW_OPENED)); 
} 


void GameEngine::InitTestData() 
{ 
    // An array of 3 vectors which represents 3 vertices 
    static const GLfloat g_vertex_buffer_data[] = { 
     -1.0f, -1.0f, 0.0f, 
     1.0f, -1.0f, 0.0f, 
     0.0f, 1.0f, 0.0f, 
    }; 

} 

Mit meinem gemeinsamen Rubrik:

#ifndef _COMMON_H 
#define _COMMON_H 

// OpenGL Libraries 
#define GLEW_STATIC 
//#pragma comment(lib, "glew32.lib") 
#include <GL\glew.h> 
#include <GL\glfw.h> 

// Core Libraries 
#include <Windows.h> 
#include <stdio.h> 
#include <stdlib.h> 
#include <map> 
#include <string> 
#include <fstream> 

// C++ 11 Libraries 
#include <memory> 
#include <exception> 
#include <thread> 
#include <chrono> 

// Manager Classes 
#include "ThreadManager.h" 
#include "GameEngine.h" 
#include "ShaderManager.h" 

// Lesser Classes 
#include "Shader.h" 

#endif 

Answer 1

Wenn kein Fehler von glewInit() ist das Ergebnis 0. Für zurückgegeben Ein Grund, warum die Rückgabe nicht gut mit GLEW_OK verglichen wurde, aber wenn der Wert alles andere als 0 ist, liegt ein Fehler vor.

Answer 2

Sie verwenden Core OpenGL Version 3.3, so müssen Sie angeben, Sie verwenden "neue" und GLEW Begriffe "experimentelle" API. Fügen Sie diese Zeile hinzu, bevor Sie glewInit() aufrufen.

glewExperimental=GL_TRUE; 

ist der komplette Init-Code von meinem Motor .Es für 4.2 ist aber sollte das gleiche für Sie arbeitet:

void Engine::InitWithGLFW(){ 
    if(!glfwInit()){ 
     exit(EXIT_FAILURE); 
    } 
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MAJOR, 4); 
    glfwOpenWindowHint(GLFW_OPENGL_VERSION_MINOR, 2); 
    //glfwOpenWindowHint(GLFW_OPENGL_FORWARD_COMPAT,GL_TRUE); 
    glfwOpenWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_COMPAT_PROFILE); 
    glfwOpenWindowHint(GLFW_FSAA_SAMPLES,4); 
    glfwDisable(GLFW_AUTO_POLL_EVENTS); 

#ifdef DEBUG 
    glfwOpenWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GL_TRUE); 
#endif 

    if(!glfwOpenWindow(_width,_height,8, 8, 8, 8, 24, 8,GLFW_WINDOW)){ 
     glfwTerminate(); 
     exit(EXIT_FAILURE); 
    } 

    glfwSetWindowTitle("XDEngine V-1.0"); 
    InitGlew(); 
} 

void Engine::InitGlew(){ 
    glewExperimental=GL_TRUE; 
    GLenum err = glewInit(); 

    if (GLEW_OK != err) 
    { 
     /* Problem: glewInit failed, something is seriously wrong. */ 
     fprintf(stderr, "Error: %s\n", glewGetErrorString(err)); 

    } 

    fprintf(stdout, "Status: Using GLEW %s\n", glewGetString(GLEW_VERSION)); 
    glEnable (GL_BLEND); 
    glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); 

    glEnable(GL_MULTISAMPLE); 
    glEnable(GL_DEPTH_CLAMP); 
    glEnable(GL_CULL_FACE); 
    glCullFace(GL_BACK); 

    glfwSetWindowSizeCallback(Reshape); 
} 

Answer 3

Ich hatte ein ähnliches Problem und bekam schließlich die Lösung opengl.org. Es scheint, dass GLEW-Entwickler noch kein Kernkontextproblem behoben haben. Zwar gibt es eine ganz einfache Lösung:

glewExperimental=TRUE; 
    GLenum err=glewInit(); 
    if(err!=GLEW_OK) 
    { 
    //Problem: glewInit failed, something is seriously wrong. 
    cout<<"glewInit failed, aborting."<<endl; 
    } 

HTH

Answer 4

ich diese Antwort weiß, ein bisschen spät kommt, aber ich sehe nicht, dass Sie die OpenGL-Kontext aktuellen machen von glfwMakeContextCurrent(window) aufrufen. Sie müssen das tun, bevor Sie anrufen glewInit()