OpenGL 3 + Black - C++

Question

ich einen schwarzen Bildschirm nach einem einfachen Dreieck auf OpenGL mit dem SDL2 zu bekommen versuchen ...

ich initialisieren tatsächlich das Fenster mit OpenGL und starten GLEW mit einem Objektnamen als „EngineOpenGL ": http://pastebin.com/S4YDgY45

Dann beginne ich eine Szene, die Rendering das Dreieck soll: "SceneOpenGL": http://pastebin.com/GD4f5UDj

die Hauptdatei:

#include <SDL.h> 
#include <iostream> 
#include <GL\glew.h> 
#include "EngineOpenGl.h" 

// DEBUG_MemoryLeaks 
#define _CRTDBG_MAP_ALLOC 
#include <stdlib.h> 
#include <crtdbg.h> 
// _DEBUG 

#include "SDLInitVideoException.h" 
int main(int argc, char **argv) { 
    _CrtDumpMemoryLeaks(); 

    EngineOpenGL * scene = new EngineOpenGL("OpenGL", 720, 1280); 
    try { 
     scene->init(); 
    } catch (const SDLInitVideoException &e) { 
     delete scene; 
     std::cout << "Error while initialising SDL" << std::endl; 
    } catch (const SDLCreateWindowException &e) { 
     delete scene; 
     std::cout << "Error while initialising the window" << std::endl; 
    } catch (const SDLCreateContextGLException &e) { 
     delete scene; 
     std::cout << "Error while creating the contextGL" << std::endl; 
    } catch (const GLEWInitException &e) { 
     delete scene; 
     std::cout << "Error while initialising " << std::endl; 
    } catch (const SceneOpenGLException &e) { 
     delete scene; 
     std::cout << "Error while starting the scene" << std::endl; 
    } 
    scene->start(); 
    delete scene; 

    // DEBUG_MemoryLeaks 
    _CrtDumpMemoryLeaks(); 
    // _DEBUG 
    return 0; 
} 

FPS zeigen die fps in der Konsole und Input erhält die Benutzereingabe.

Edit: Ich habe versucht, eigentlich nur zum Kopieren/Vergangenheit ein Code für Dreieck-Rendering und halten sie nicht funktioniert ...

 #include "SceneOpenGl.h" 

// Shader temporaire : 
#include "Shader.h" 

SceneOpenGL::SceneOpenGL(SDL_Window* window) { 
    if (window == NULL) { 
     throw new SceneOpenGLException(); 
    } 
    // Engine 
    this->window = window; 
    // Tools 
    this->fps = new FPSCount(); 
    this->input = new Input(); 
    // Scene 
    this->run = false; 

    int w, h; 
    SDL_GetWindowSize(window, &w, &h); 
    this->projection = glm::perspective(70.0, (double)(w/h), 1.0, 100.0); 
    this->modelview = glm::mat4(1.0); 
} 


SceneOpenGL::~SceneOpenGL(){ 
    delete fps; 
    delete input; 
} 

void SceneOpenGL::start() { 
    run = true; 

    // Test en attendant ObjectGL.show() // 
    GLfloat vertices[] = { 
     0.5f, 0.5f, 0.0f, // Top Right 
     0.5f, -0.5f, 0.0f, // Bottom Right 
     -0.5f, -0.5f, 0.0f, // Bottom Left 
     -0.5f, 0.5f, 0.0f // Top Left 
    }; 
    GLuint indices[] = { // Note that we start from 0! 
     0, 1, 3, // First Triangle 
     1, 2, 3 // Second Triangle 
    }; 
    // Build and compile our shader program 
    // Vertex shader 
    const GLchar* vertexShaderSource = "#version 330 core\n" 
     "layout (location = 0) in vec3 position;\n" 
     "void main()\n" 
     "{\n" 
     "gl_Position = vec4(position.x, position.y, position.z, 1.0);\n" 
     "}\0"; 
    const GLchar* fragmentShaderSource = "#version 330 core\n" 
     "out vec4 color;\n" 
     "void main()\n" 
     "{\n" 
     "color = vec4(1.0f, 0.5f, 0.2f, 1.0f);\n" 
     "}\n\0"; 

    GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER); 
    glShaderSource(vertexShader, 1, &vertexShaderSource, NULL); 
    glCompileShader(vertexShader); 
    // Check for compile time errors 
    GLint success; 
    GLchar infoLog[512]; 
    glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success); 
    if (!success) 
    { 
     glGetShaderInfoLog(vertexShader, 512, NULL, infoLog); 
     std::cout << "ERROR::SHADER::VERTEX::COMPILATION_FAILED\n" << infoLog << std::endl; 
    } 
    // Fragment shader 
    GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER); 
    glShaderSource(fragmentShader, 1, &fragmentShaderSource, NULL); 
    glCompileShader(fragmentShader); 
    // Check for compile time errors 
    glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success); 
    if (!success) 
    { 
     glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog); 
     std::cout << "ERROR::SHADER::FRAGMENT::COMPILATION_FAILED\n" << infoLog << std::endl; 
    } 
    // Link shaders 
    GLuint shaderProgram = glCreateProgram(); 
    glAttachShader(shaderProgram, vertexShader); 
    glAttachShader(shaderProgram, fragmentShader); 
    glLinkProgram(shaderProgram); 
    // Check for linking errors 
    glGetProgramiv(shaderProgram, GL_LINK_STATUS, &success); 
    if (!success) { 
     glGetProgramInfoLog(shaderProgram, 512, NULL, infoLog); 
     std::cout << "ERROR::SHADER::PROGRAM::LINKING_FAILED\n" << infoLog << std::endl; 
    } 
    glDeleteShader(vertexShader); 
    glDeleteShader(fragmentShader); 

    GLuint VBO, VAO, EBO; 
    glGenVertexArrays(1, &VAO); 
    glGenBuffers(1, &VBO); 
    glGenBuffers(1, &EBO); 
    // Bind the Vertex Array Object first, then bind and set vertex buffer(s) and attribute pointer(s). 
    glBindVertexArray(VAO); 

    glBindBuffer(GL_ARRAY_BUFFER, VBO); 
    glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 

    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); 
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); 

    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(GLfloat), (GLvoid*)0); 
    glEnableVertexAttribArray(0); 

    glBindBuffer(GL_ARRAY_BUFFER, 0); // Note that this is allowed, the call to glVertexAttribPointer registered VBO as the currently bound vertex buffer object so afterwards we can safely unbind 

    glBindVertexArray(0); // Unbind VAO (it's always a good thing to unbind any buffer/array to prevent strange bugs), remember: do NOT unbind the EBO, keep it bound to this VAO 


    // /Test // 

    while (run) { 
     // FPS flag 
     if (fps->flag()) { 
      std::cout << "FPS : " << fps->getFps() << std::endl; 
     } 

     // Input check/actions 
     input->updateEvents(); 
     if (input->isKeyPush(SDL_SCANCODE_ESCAPE)) { 
      run = false; 
     } 

     // Cleaning last frame 
     glClear(GL_COLOR_BUFFER_BIT); 

     // Test // 
     glClearColor(0.2f, 0.3f, 0.3f, 1.0f); 
     glClear(GL_COLOR_BUFFER_BIT); 

     // Draw our first triangle 
     glUseProgram(shaderProgram); 
     glBindVertexArray(VAO); 
     //glDrawArrays(GL_TRIANGLES, 0, 6); 
     glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0); 
     glBindVertexArray(0); 


     // FPS add frame 
     fps->addFrame(); 

     // Rendering 
     SDL_GL_SwapWindow(window); 
    } 
} 

Answer 1

Zu keinem Zeitpunkt werden geladen Sie Ihre Vertexdaten in den Videospeicher. Sie haben eine Linie, die wie ein Versuch, sieht die Ecken in den Videospeicher zu laden:

glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 0, vertices); 

.... Aber das ist nicht das, was die Funktion tut.

Sie benötigen eine Vertex-Array und einen Vertex Buffer erstellen und binden:

GLuint vertex_array_id; 
glGenVertexArrays(1, &vertex_array_id); 
glBindVertexArray(vertex_array_id); 
GLuint vertex_buffer_id; 
glGenBuffers(1, &vertex_buffer_id); 
glBindBuffer(GL_ARRAY_BUFFER, vertex_buffer_id); 

Dann, während die Vertex-Array und Vertex Buffer gebunden sind, müssen Sie explizit, um Daten in den Puffer:

glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW); 

Dann verwenden Sie glVertexAttribPointer, um anzugeben, wie die Daten ausgelegt sind.

glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, sizeof(GLfloat) * 2, nullptr); 
glEnableVertexAttribArray(0); 

All dieser Code sollte übrigens außerhalb der Schleife liegen. Dann müssen Sie innerhalb der Zeichnungsschleife einfach glDrawArrays anrufen.