ComputeShaderProgram.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_COMPUTE_SHADER_PROGRAM_HPP
#define CSCI441_COMPUTE_SHADER_PROGRAM_HPP
 
#include "LogUtils.hpp"
#include "ShaderProgram.hpp"
 
 
namespace CSCI441 {
 
    class ComputeShaderProgram final : public ShaderProgram {
    public:
        explicit ComputeShaderProgram( const char *computeShaderFilename );
 
        ~ComputeShaderProgram() override = default;
 
        ComputeShaderProgram(const ComputeShaderProgram&) = delete;
        ComputeShaderProgram& operator=(const ComputeShaderProgram&) = delete;
 
        ComputeShaderProgram(ComputeShaderProgram&&) noexcept = default;
        ComputeShaderProgram& operator=(ComputeShaderProgram&&) noexcept = default;
 
        [[maybe_unused]] void dispatchWork(GLuint numGroupsX, GLuint numGroupsY, GLuint numGroupsZ) const;
 
        [[maybe_unused]] [[nodiscard]] GLbitfield getProgramStages() const override;
 
    protected:
        GLuint mComputeShaderHandle;
    };
 
}
 
 
inline CSCI441::ComputeShaderProgram::ComputeShaderProgram( const char *computeShaderFilename ) : mComputeShaderHandle(0) {
    GLint major, minor;
    glGetIntegerv(GL_MAJOR_VERSION, &major);
    glGetIntegerv(GL_MINOR_VERSION, &minor);
 
    if(major < 4 || (major == 4 && minor < 3)) {
        CSCI441::LogUtils::logError("[ERROR]: Compute Shaders only supported in OpenGL 4.3+\n");
        return;
    }
 
    if( sDEBUG ) CSCI441::LogUtils::log("\n[INFO]: /--------------------------------------------------------\\\n");
 
    // compile each one of our shaders
    if( strcmp( computeShaderFilename, "" ) != 0 ) {
        if( sDEBUG ) CSCI441::LogUtils::log("[INFO]: | Compute Shader: %38s |\n", computeShaderFilename );
        mComputeShaderHandle = CSCI441_INTERNAL::ShaderUtils::compileShader(computeShaderFilename, GL_COMPUTE_SHADER );
    } else {
        mComputeShaderHandle = 0;
    }
 
    // get a handle to a shader program
    mShaderProgramHandle = glCreateProgram();
 
    // attach the computer fragment shader to the shader program
    if(mComputeShaderHandle != 0 ) {
        glAttachShader(mShaderProgramHandle, mComputeShaderHandle );
    }
 
    // link all the programs together on the GPU
    glLinkProgram(mShaderProgramHandle );
 
    if( sDEBUG ) CSCI441::LogUtils::log("[INFO]: | Shader Program: %41s", "|\n" );
 
    // check the program log
    CSCI441_INTERNAL::ShaderUtils::printProgramLog(mShaderProgramHandle );
 
    // detach & delete the vertex and fragment shaders to the shader program
    if(mComputeShaderHandle != 0 ) {
        glDetachShader(mShaderProgramHandle, mComputeShaderHandle );
        glDeleteShader(mComputeShaderHandle );
    }
 
    // map uniforms
    mpUniformLocationsMap = new std::map<std::string, GLint>();
    GLint numUniforms;
    glGetProgramiv(mShaderProgramHandle, GL_ACTIVE_UNIFORMS, &numUniforms);
    GLint max_uniform_name_size;
    glGetProgramiv(mShaderProgramHandle, GL_ACTIVE_UNIFORM_MAX_LENGTH, &max_uniform_name_size);
    if( numUniforms > 0 ) {
        for(GLuint i = 0; i < numUniforms; i++) {
            char* name = (char*) malloc(max_uniform_name_size * sizeof(char));
            int actual_length = 0;
            int size = 0;
            GLenum type;
            glGetActiveUniform(mShaderProgramHandle, i, max_uniform_name_size, &actual_length, &size, &type, name );
            GLint location = -1;
            if(size > 1) {
                for(int j = 0; j < size; j++) {
                    int max_array_size = actual_length + 4 + 2 + 1;
                    char* array_name = (char*) malloc(max_array_size * sizeof(char));
                    snprintf(array_name, max_array_size, "%s[%i]", name, j);
                    location = glGetUniformLocation(mShaderProgramHandle, array_name);
                    mpUniformLocationsMap->emplace(array_name, location);
                    free(array_name);
                }
            } else {
                location = glGetUniformLocation(mShaderProgramHandle, name);
                mpUniformLocationsMap->emplace(name, location);
            }
            free(name);
        }
    }
    GLint linkStatus;
    glGetProgramiv(mShaderProgramHandle, GL_LINK_STATUS, &linkStatus );
 
    /* print shader info for uniforms & attributes */
    if(linkStatus == 1) {
        // print shader info for uniforms & attributes
        CSCI441_INTERNAL::ShaderUtils::printShaderProgramInfo(mShaderProgramHandle, false, false, false, false, false,
                                                              mComputeShaderHandle != 0, true);
    }
}
 
[[maybe_unused]]
inline void CSCI441::ComputeShaderProgram::dispatchWork(const GLuint numGroupsX = 1, const GLuint numGroupsY = 1, const GLuint numGroupsZ = 1) const {
    glDispatchCompute(numGroupsX, numGroupsY, numGroupsZ);
}
 
[[maybe_unused]]
inline GLbitfield CSCI441::ComputeShaderProgram::getProgramStages() const {
    GLbitfield shaderBits = 0;
    if( mComputeShaderHandle != 0 ) shaderBits |= GL_COMPUTE_SHADER_BIT;
    return shaderBits;
}
 
#endif // CSCI441_COMPUTE_SHADER_PROGRAM_HPP