GL_UseProgram不会影响着色器

Question

It seems like my useProgram doesn't bind the shader so I cant set uniforms to it. But when I use GlUseProgram in the compile code for the shader I can set uniforms. I am using a resourcemanager to handle the shaders and textures and a Game file to handle the shader/texter/game setup.

Shader.h:

class Shader
{
    Shader() {};
    void Compile(const std::string& vertexSource, const std::string& fragmentSource, const char* geometrySource = nullptr);
    Shader  &Use();
}

Shader.cpp

Shader & Shader::Use()
}
    glUseProgram(this->ID);
    return *this;
{

void Shader::Compile(const std::string& vertexSource, const std::string& 
    fragmentSource, const char* geometrySource)
{
    unsigned int vShader, fShader, gShader;

    const char* src1 = vertexSource.c_str();
    const char* src2 = fragmentSource.c_str();

    vShader = glCreateShader(GL_VERTEX_SHADER);
    glShaderSource(vShader, 1, &src1, NULL);
    glCompileShader(vShader);
    checkCompileErrors(vShader, "VERTEX");

    fShader = glCreateShader(GL_FRAGMENT_SHADER);
    glShaderSource(fShader, 1, &src2, NULL);
    glCompileShader(fShader);
    checkCompileErrors(fShader, "FRAGMENT");

    if (geometrySource != nullptr)
    {
        gShader = glCreateShader(GL_GEOMETRY_SHADER);
        glShaderSource(gShader, 1, &geometrySource, NULL);
        glCompileShader(gShader);
        checkCompileErrors(gShader, "error");
    }

    this->ID = glCreateProgram();
    glAttachShader(this->ID, vShader);
    glAttachShader(this->ID, fShader);

    if (geometrySource != nullptr)
    {
        glAttachShader(this->ID, gShader);
    }
    glLinkProgram(this->ID);
    checkCompileErrors(this->ID, "PROGRAM");

    //glUseProgram(this->ID);

    glDeleteShader(vShader);
    glDeleteShader(fShader);
    if (geometrySource != nullptr)
    {
        glDeleteShader(gShader);
    }
}

You can see where I have comment out GlUseProgram. If I dont comment it out the shader will work properly but if I do comment It out it will not work.

ResourceManager.h:

class ResourceManager
{
public:
    // Resource storage
    static std::unordered_map<std::string, Shader>    shader;
    static Shader loadShader(const std::string& vShaderSource, std::string filename);
    static Shader getShader(std::string name);
    static Shader loadShaderFromFile(const std::string& vShaderFile);

ResourceManager.cpp

std::unordered_map<std::string, Shader> ResourceManager::shader;
Shader ResourceManager::loadShader(const std::string& vShaderSource, std::string filename)
{
    shader[filename] = loadShaderFromFile(vShaderSource);
    return shader[filename];
}

Shader ResourceManager::getShader(std::string filename)
{
    return shader[filename];
}

Shader ResourceManager::loadShaderFromFile(const std::string& vShaderFile)
{
    enum class ShaderType
    {
        none = -1, vertex = 0, fragment = 1
    };

    std::fstream path(vShaderFile);
    std::stringstream ss[2];
    std::string string;
    ShaderType type = ShaderType::none;

    while (std::getline(path, string))
    {
        if (string.find("shader") != std::string::npos) 
        {
            if (string.find("vertex") != std::string::npos)
            {
                type = ShaderType::vertex;
            }
            if (string.find("fragment") != std::string::npos)
            {
                type = ShaderType::fragment;
            }
        }
        else
            ss[(int)type] << string << "\n";
    }

    std::string vertexCode = ss[0].str();
    std::string fragmentCode = ss[1].str();
    const char* geomtryCode = nullptr;

    Shader shader;
    shader.Compile(vertexCode, fragmentCode);

    return shader;
}

And finally. Game.cpp:

void Game::Init()
{
    ResourceManager::loadShader("res/Shader/shader.shader", "sprite");
    ResourceManager::getShader("sprite").Use().setUniform1i("image", 0);
    ResourceManager::getShader("sprite").setUniformMatrix4fv("projection", projection);
}

Would someone explain why it doesn't seems to work?

Answer 1

Looking into the 4.6 specification , section 7.1, about DeleteShader() it only says:

If shader is not attached to any program object, it is deleted immediately. Otherwise, shader is flagged for deletion and will be deleted when it is no longer attached to any program object.

At section 7.3, about UseProgram()

An INVALID_OPERATION error is generated if program has not been linked successfully. The current rendering state is not modified.

and

While a program object is in use, applications are free to modify attached shader objects, compile attached shader objects, attach additional shader objects, and detach shader objects. These operations do not affect the link status or executable code of the program object.

You see, apparently you could call glUseProgram() anywhere after successfully linking.
If it doesn't work for you it could be a bug in the driver of your gfx card.

But read it again and pay attention to it tells about detach shaders, not delete shaders.

In short, detach a shader ( glDetachShader ) before deleting it ( glDeleteShader ).