Hi,

I can't run properly the following code with shaders. If a activate the "old" opengl approach it work just fine.
I can move the camera around and everything work as it should be (Is a simply square in the plane XY with lengths 2000).

I'm using the last version available for glfw, glew and glm on a Windows 10, x64 machine

Code :
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glClearColor(1, 1, 1, 1);
glEnable(GL_DEPTH_TEST);
glCullFace(GL_FRONT_AND_BACK);
glDrawBuffer(GL_FRONT_AND_BACK);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
 
m_perspective = glm::perspective(5.0f, m_sizeEvent.width() / (float)m_sizeEvent.height(), 10.0f, 10000.0f);
m_lookAt = glm::lookAt(m_camera.position(), m_camera.lookingAt(), glm::vec3(0.0f, 0.0f, -1.0f));;
 
if (true)
{
    //new opengl
    glm::mat4 transformation = m_perspective * m_lookAt;
 
    for (Meshes::Item &mesh : m_meshes)
        mesh->render(transformation);
}
else 
{
    //  old opengl
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    glMultMatrixf(&m_perspective[0][0]);
 
    glMatrixMode(GL_MODELVIEW);
    glLoadIdentity();
    glMultMatrixf(&m_lookAt[0][0]);
 
    for (Meshes::Item &mesh : m_meshes)
        mesh->oldRender();
}

I can read the shaders without any exception as follow:
Code :
	Shader::Shader(const std::string& verteShader, const std::string& fragmentShader)
    {
        m_program = glCreateProgram();
        m_shaders[VERTEX_SHADER] = createShader(verteShader, GL_VERTEX_SHADER);
        m_shaders[FRAGMENT_SHADER] = createShader(fragmentShader, GL_FRAGMENT_SHADER);
 
        glAttachShader(m_program, m_shaders[VERTEX_SHADER]);
        glAttachShader(m_program, m_shaders[FRAGMENT_SHADER]);
 
        glBindAttribLocation(m_program, 0, "position");
 
        glLinkProgram(m_program);
        checkShaderError(m_program, GL_LINK_STATUS, true, "Error: glProgram linking failed ");
 
        glValidateProgram(m_program);
        checkShaderError(m_program, GL_VALIDATE_STATUS, true, "Error: glProgram validating failed ");
 
        m_transformation[TRANSFORMATION] = glGetUniformLocation(m_program, "transform");
 
        if (m_transformation[TRANSFORMATION] < 0)
            throw Exception("transformation variable can not be set in the shader!");
    }
    ....
 
    //  public interface
    void Shader::bind(const glm::mat4& transformation)
    {
        glUseProgram(m_program);
 
 
        glUniformMatrix4fv(m_transformation[TRANSFORMATION], 1, GL_FALSE, &transformation[0][0]);
 
    }
 
    //  private interface
    GLuint Shader::createShader(const std::string& text, unsigned int type)
    {
        GLuint shader = glCreateShader(type);
 
        if (shader == 0)
            throw Exception::create("Error compiling shader type: {0}", type);
 
        const GLchar* shaderSourceStrings[1];
        GLint shaderSourcesStringLength[1];
 
        shaderSourceStrings[0] = text.c_str();
        shaderSourcesStringLength[0] = (GLint)text.length();
 
        glShaderSource(shader, 1, shaderSourceStrings, shaderSourcesStringLength);
        glCompileShader(shader);
 
        checkShaderError(shader, GL_COMPILE_STATUS, false, "Error compiling shader!");
 
        return shader;
    }
 
    void Shader::checkShaderError(GLuint shader, GLuint flag, bool isProgram, std::string errorMessage)
    {
        GLint success = GL_FALSE;
        GLchar error[3024] = { 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);
 
            throw Exception::create("{0} : {1}", errorMessage, error);
 
        }
    }

my vertexShader code:
Code :
#version 400
 
in vec3 position;
 
uniform mat4 transform;
 
void main()
{
	gl_Position = transform  * vec4(position,0);
}

my fragment code:
Code :
#version 400
 
 
void main()
{
	gl_FragColor = vec4(0.0,0.0,1.0,0.5);
}


my mesh code:
Code :
    void xMesh::render(const glm::mat4 &transformation)
    {
        if (m_vertexCount == 0 || m_shader == nullptr)
            return;
 
        m_shader->bind(transformation);
 
        glBindVertexArray(m_vertexArrayObject);
        glDrawArrays(GL_TRIANGLES, 0, m_vertexCount);
        glBindVertexArray(0);
    }
 
    void xMesh::loadMesh(xVertices &vertices)
    {
        m_vertexCount = (int)vertices.size();
 
        glGenVertexArrays(1, &m_vertexArrayObject);
        glBindVertexArray(m_vertexArrayObject);
 
        glGenBuffers(NUM_BUFFERS, m_vertexArrayBuffers);
        glBindBuffer(GL_ARRAY_BUFFER, m_vertexArrayBuffers[POSITION_VB]);
        glBufferData(GL_ARRAY_BUFFER, sizeof(xVertex)*m_vertexCount, &vertices[0], GL_STATIC_DRAW);
 
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
 
        glBindVertexArray(0);
    }

any ideas, what I'm doing wrong?