shaderProgram.h

#pragma once
 
#include <glad/glad.h>
 
#include <string>
#include <vector>
 
namespace Aire {
    struct ShaderSource {
        GLenum type;
        std::string sourcePath;
    };
 
    class ShaderProgram {
    public:
        explicit ShaderProgram(std::vector<ShaderSource> shaderList = {});
 
        GLuint getProgramId() const;
 
        void reloadShaders();
 
        void useProgram();
 
        ~ShaderProgram();
 
        // Delete copy constructor and assignment operator
        ShaderProgram( ShaderProgram const& ) = delete;
        ShaderProgram& operator= (ShaderProgram const&) = delete;
 
        void set2DTextureUniform(const char* uniformName, const GLuint textureHandle);
 
        void setCubeTextureUniform(const char* uniformName, const GLuint textureHandle);
 
        void unbindAllTextures();
 
        void unbind2DTextures(int numTextures);
 
        void unbindCubeTextures(int numTextures);
 
    private:
        GLuint programId;
        std::vector<ShaderSource> shaderSources;
 
        GLuint current2DTextureUnit = 0;
        GLuint currentCubeTextureUnit = 0;
    };
 
    //##########################################//
    //######## INLINE DEFINITIONS BELOW ########//
    //##########################################//
 
    inline GLuint ShaderProgram::getProgramId() const {
        return programId;
    }
 
    inline void ShaderProgram::useProgram() {
        glUseProgram(programId);
 
        current2DTextureUnit = 0;
        currentCubeTextureUnit = 0;
    }
 
    inline void ShaderProgram::set2DTextureUniform(const char* uniformName, const GLuint textureHandle) {
        glActiveTexture(GL_TEXTURE0 + current2DTextureUnit);
        glBindTexture(GL_TEXTURE_2D, textureHandle);
        glUniform1i(glGetUniformLocation(programId, uniformName), current2DTextureUnit);
        current2DTextureUnit++;
    }
 
    inline void ShaderProgram::setCubeTextureUniform(const char* uniformName, const GLuint textureHandle) {
        glActiveTexture(GL_TEXTURE0 + currentCubeTextureUnit);
        glBindTexture(GL_TEXTURE_CUBE_MAP, textureHandle);
        glUniform1i(glGetUniformLocation(programId, uniformName), currentCubeTextureUnit);
        currentCubeTextureUnit++;
    }
 
    inline void ShaderProgram::unbindAllTextures() {
        for (GLuint i = 0; i < current2DTextureUnit; i++) {
            glActiveTexture(GL_TEXTURE0 + i);
            glBindTexture(GL_TEXTURE_2D, 0);
            current2DTextureUnit--;
        }
        for (GLuint i = 0; i < currentCubeTextureUnit; i++) {
            glActiveTexture(GL_TEXTURE0 + i);
            glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
            currentCubeTextureUnit--;
        }
    }
 
    inline void ShaderProgram::unbind2DTextures(int numTextures) {
        for (GLuint i = 0; i < numTextures; i++) {
            glActiveTexture(GL_TEXTURE0 + current2DTextureUnit - 1);
            glBindTexture(GL_TEXTURE_2D, 0);
            current2DTextureUnit--;
        }
    }
 
    inline void ShaderProgram::unbindCubeTextures(int numTextures) {
        for (GLuint i = 0; i < numTextures; i++) {
            glActiveTexture(GL_TEXTURE0 + currentCubeTextureUnit - 1);
            glBindTexture(GL_TEXTURE_CUBE_MAP, 0);
            currentCubeTextureUnit--;
        }
    }
 
}