OpenGL ignoring Shaders

Question

OpenGl seems to be ignoring my shaders, not scalling, or changing the color. Screenshot

I dont get any errors, throught the errorhandler either. I have been at it for hours, what am i doing wrong?

im using freeglut and glew(dont know it that matters).

Im doing this with:

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

}       

Fragment 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 + "'");
    }
}

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

main and init function:

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

This code in your Mesh constructor does not look right:

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

You probably meant to pass m_vertexArrayObject as the argument to glBindVertexArray().