のOpenGL 3+ BlackScreen - C++

Question

私はSDL2とのOpenGLの簡単な三角形を取得しようとした後、黒い画面を得る...

私は実際のOpenGLでウィンドウを初期化し、EngineOpenGL」などのオブジェクト名でGLEWを開始"：http://pastebin.com/S4YDgY45

は、その後、私は三角形をレンダリングすることになったシーンを開始します。 "SceneOpenGL"：http://pastebin.com/GD4f5UDj

メインファイル：

#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はコンソールにfpsを表示し、Inputはユーザー入力を取得します。

編集：私は実際にちょうど三角形をレンダリングするためのコードを過ぎて/コピーしようとしましたが、それは動作しません保つ...

 #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

なし時点で、あなたがビデオメモリにあなたの頂点データをロードしています。あなたはは、ビデオメモリに頂点をロードしようとのような行があります。

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

を....しかし、それはその関数が何をするかではありません。

あなたは頂点配列と頂点バッファを作成してバインドする必要があります。

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); 

次に、この頂点配列と頂点バッファがバインドされている間、あなたが明示的にバッファにデータを提供する必要があります。

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

次に、glVertexAttribPointerを使用して、データのレイアウト方法を指定します。

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

すべてのコードは、おそらくループ外にあるはずです。ドローループの中で、glDrawArraysに電話するだけです。