OpenGL игнорирует шейдеры

Question

OpenGl, похоже, игнорирует мои шейдеры, а не царапает или меняет цвет. Screenshot

Я также не получаю никаких ошибок, также через обработчик ошибок. Я был у него часами, что я делаю неправильно?

im Использование freeglut и glew (не знаю, что имеет значение).

Я делаю это с:

• OpenGl 4,3

• Radeon HD 6800

• для Windows 8.1 Enterprise

Vertex Shader:

#version 120 

attribute vec3 position; 

void main() 
{ 
    gl_Position = vec4(position*2.0,1.0); 

}  

Фрагмент Shader:

#version 120 

void main() 
{ 
    gl_FragColor = vec4(0.0, 1.0, 0.0, 1.0); 
} 

Shader.cpp

#include "Shader.h" 
#include <fstream> 
#include "ErrorHandler.h" 

namespace{ 
    std::string VERTEX_SHADER_EXTENSION = ".vs"; 
    std::string FRAGMENT_SHADER_EXTENSION = ".fs"; 
} 

Shader::Shader(const std::string& fileName) 
{ 
    m_program = glCreateProgram(); 
    m_shaders[0] = CreateShader(LoadShader(fileName + VERTEX_SHADER_EXTENSION), GL_VERTEX_SHADER); 
    m_shaders[1] = CreateShader(LoadShader(fileName + FRAGMENT_SHADER_EXTENSION), GL_FRAGMENT_SHADER); 

    for (unsigned int i = 0; i < NUM_SHADERS; i++) 
    { 
     glAttachShader(m_program, m_shaders[i]); 
    } 
      glBindAttribLocation(m_program, 0, "position"); 

    glLinkProgram(m_program); 
    CheckShaderError(m_program, GL_LINK_STATUS, true, "Program linking failed: "); 
    glValidateProgram(m_program); 
    CheckShaderError(m_program, GL_VALIDATE_STATUS, true, "Program is invalid: "); 
} 

void Shader::Bind() 
{ 
    glUseProgram(m_program); 
} 

Shader::~Shader() 
{ 
    for (unsigned int i = 0; i < NUM_SHADERS; i++) 
    { 
     glDetachShader(m_program, m_shaders[i]); 
     glDeleteShader(m_shaders[i]); 
    } 
    glDeleteProgram(m_program); 
} 

GLuint Shader::CreateShader(const std::string& text, GLenum shaderType) 
{ 
    GLuint shader = glCreateShader(shaderType); 
    if (shader == 0) 
    { 
     ErrorHandler::LogError("Error: Shader creation failed!"); 
    } 
    const GLchar* shaderSourceStrings[1]; 
    GLint shaderSourceStringLength[1]; 

    shaderSourceStringLength[0] = text.length(); 
    shaderSourceStrings[0] = text.c_str(); 

    glShaderSource(shader, 1, shaderSourceStrings, shaderSourceStringLength); 
    glCompileShader(shader); 
    CheckShaderError(shader, GL_COMPILE_STATUS, false, "Shader compilation failed: "); 
    return shader; 
} 
std::string Shader::LoadShader(const std::string& fileName) 
{ 
    std::ifstream file; 
    file.open((fileName).c_str()); 
    std::string output; 
    std::string line; 

    if (file.is_open()) 
    { 
     while(file.good()) 
     { 
      getline(file, line); 
      output.append(line + "\n"); 
     } 
    } 
    else 
    { 
     ErrorHandler::LogError("Unable to load shader: " + fileName); 
    } 
    return output; 

} 
void Shader::CheckShaderError(GLuint shader, GLuint flag, bool isProgram, const std::string& errorMessage) 
{ 
    GLint success = 0; 
    GLchar error[1024] = { 0 }; 

    if (isProgram) 
     glGetProgramiv(shader, flag, &success); 
    else 
     glGetShaderiv(shader, flag, &success); 

    if (success == GL_FALSE) 
    { 
     if (isProgram) 
      glGetProgramInfoLog(shader, sizeof(error), NULL, error); 
     else 
      glGetShaderInfoLog(shader, sizeof(error), NULL, error); 

     ErrorHandler::LogError(errorMessage + ": " + error + "'"); 
    } 
} 

Loop игры:

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); 
Shaders[0].Bind(); 
Meshes[0].Draw(); 
glutSwapBuffers(); 

Mesh.cpp:

#include "Mesh.h" 


Mesh::Mesh(Vertex* vertices, unsigned int numVertices) 
{ 
    m_drawCount = numVertices; 
    glGenVertexArrays(1, &m_vertexArrayObject); 
    glBindVertexArray(*m_vertexArrayBuffers); 
    glGenBuffers(NUM_BUFFERS, m_vertexArrayBuffers); 
    glBindBuffer(GL_ARRAY_BUFFER,m_vertexArrayBuffers[POSITION_VB]); 
    glBufferData(GL_ARRAY_BUFFER, numVertices * sizeof(vertices[0]), vertices, GL_STATIC_DRAW); 
    glEnableVertexAttribArray(0); 
    glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0); 
    glBindVertexArray(0); 
} 


Mesh::~Mesh() 
{ 
    glDeleteVertexArrays(1, &m_vertexArrayObject); 
} 

void Mesh::Draw() 
{ 
    glBindVertexArray(m_vertexArrayObject); 
    glDrawArrays(GL_TRIANGLES, 0, m_drawCount); 
    glBindVertexArray(0); 
} 

основной и инициализации функции:

int init(int argc, char** argv) 
{ 
    //init glut 
    glutInit(&argc, argv); 
    Display display(800, 600, "OpenGL Playground"); 
    //init glew 
    GLenum err = glewInit(); 
    if (GLEW_OK != err){ 
     ErrorHandler::LogError(std::string(reinterpret_cast<const char*>(glewGetErrorString(err)))); 
     return 1; 
    } 

    //bind functions 
    glutDisplayFunc(draw);//Drawloop 
    return 0; 
} 
int main(int argc, char** argv) 
{ 
    int i = init(argc, argv); 
    Vertex verts[3]; 
    verts[0] = Vertex(Vector3f(-0.5f, -0.5f, 0.0f)); 
    verts[1] = Vertex(Vector3f(0.0f, 0.5f, 0.0f)); 
    verts[2] = Vertex(Vector3f(0.5f, -0.5f, 0.0f)); 
    Meshes.push_back(Mesh(verts, (sizeof(verts)/sizeof(verts[0])))); 
    Shaders.push_back(Shader("./res/basicShader")); 
    if (i == 0) 
    { 
     glutMainLoop(); 
    } 
    else 
    { 
     cin.ignore(1); 
     return 1; 
    } 
    return 0; 
} 

Display.cpp:

#include "Display.h" 
#include <GL\glut.h> 
#include <GL\freeglut.h> 
#include <iostream> 
#include "ErrorHandler.h" 

Display::Display(int width, int height, const std::string& title) 
{ 
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA | GLUT_MULTISAMPLE); 
    glutInitWindowSize(width, height); 
    glutInitWindowPosition(100, 100); 
    glutCreateWindow(title.c_str()); 
    glClearColor(0.0f, 0.2f, 0.2f, 1.0f); 
} 


Display::~Display() 
{ 
} 

Answer 1

Этот код в ваш Mesh конструктор выглядит не так:

glGenVertexArrays(1, &m_vertexArrayObject); 
glBindVertexArray(*m_vertexArrayBuffers); 
glGenBuffers(NUM_BUFFERS, m_vertexArrayBuffers); 

Вы, вероятно, означало пройти m_vertexArrayObject, как аргумент glBindVertexArray().