glAttribLocation returning -1 even though vertex shader is actively using that

Question

Searched Stack Overflow for similar questions in search of my solution , but it doesn't seem to be solved.

main.cpp :

#include"reader.h"
#include"window.h"
#include"shader.h"
int main() {

float vertices[] = {
    -0.5f, -0.5f, 0.0f ,
    0.5f, -0.5f, 0.0f , 
    0.0f,  0.5f, 0.0f 
};

Window window;

GLuint vao;
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);

Shader shader;
shader.addShader("./src/shaders/basic.vtx",GL_VERTEX_SHADER);
shader.addShader("./src/shaders/basic.frg", GL_FRAGMENT_SHADER);
shader.compile();
shader.enable();


GLuint vbo;
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);
glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices,GL_STATIC_DRAW);

GLint pos_in = glGetAttribLocation(shader.getProgram(), "pos_in");
if (pos_in < 0) {
    std::cout << "pos_in not found\n";
}
glVertexAttribPointer(pos_in, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void *)0);
glEnableVertexAttribArray(pos_in);


while (!window.closed()) {
    window.update();
    glDrawArrays(GL_TRIANGLES,0,3);
}
return 0;
}

shader.h :

#pragma once
#include<glad/glad.h>
#include<iostream>
#include<vector>
#include"reader.h"

class Shader {
std::vector<GLuint*> shaders;
GLuint program;

public :

GLuint& getProgram() { 
    return program; 
}

Shader() {
    program = glCreateProgram();
}
void addShader(const char * path, GLenum type) {

    std::string data = ShaderReader(path).read_shader();
    const char * chardata = data.c_str();
    GLuint shader = glCreateShader(type);
    glShaderSource(shader, 1, &chardata , nullptr);
    glCompileShader(shader);

    int success;
    char buffer[512];
    glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
    if (!success) {
        glGetShaderInfoLog(shader, 512, NULL, buffer);
        std::cout << buffer << std::endl;
        return;
    }
    std::cout << "shader inserted into vector\n";

    shaders.push_back(&shader);
}

void compile(){
    for (int i = 0; i != shaders.size();i++) {
        glAttachShader(program, *shaders[i]);
    }
    glLinkProgram(program);
    glValidateProgram(program);
    glUseProgram(program);
    int status;
    glGetProgramiv(program, GL_COMPILE_STATUS, &status);

    char buffer[512];
    if (!status) {
        glGetProgramInfoLog(program,512,NULL,buffer);
        std::cout << buffer << std::endl;
        return;
    }
    std::cout << "shader compilation successful\n";
}
void enable() {
    glUseProgram(program);
}
void disable() {
    glUseProgram(0);
}
~Shader() {
    for (int i = 0; i != shaders.size();i++) {
        glDeleteShader(*shaders[i]);
    }
}

};

vertex shader written in basic.vtx:

#version 400 

layout (location = 0 ) in vec3 pos_in ;

void main(){
gl_Position = vec4(pos_in.x , pos_in.y , pos_in.z , 1.0f);  
}

fragment shader written in basic.frg :

#version 400

out vec4 color;

void main(){
color = vec4(0.0f, 0.5f , 0.5f , 1.0f);
}

At the time of calling glGetAttribLocation , the vertex shader IS USING pos_in attrib to set gl_Position , yet it returns -1 . Also the triangle is not rendered when calling glGetAttribLocation() ; or rendered white with direct attrib pointer values like 0 , 1 with an openGL 1281 error.

Answer 1

One thing that is definitely not valid is the shaders.push_back(&shader):

void addShader(const char * path, GLenum type) {
    // ....

    GLuint shader = glCreateShader(type);

    // ....

    shaders.push_back(&shader);
}

With the shaders.push_back(&shader) you push back the address of a local variable to the shaders vector. So the glAttachShader(program, *shaders[i]); will result in undefined behavior.

shader holds only an numeric id so there is no need to get a pointer to that, just change the std::vector<GLuint*> shaders to std::vector<GLuint> shaders, use shaders.push_back(shader) and replace all *shaders[i] with shaders[i]

The reason why you don't get an linking error is most likely because the content at the address you get from &shader is not overwritten before you do the glAttachShader(program, *shaders[i]), and that both entries in the shaders vector hold same address of the stack. The result of is that glAttachShader is called each time on the same id, so you bind only the fragement shader to the program.