ShaderProgramPipeline.hpp

Go to the documentation of this file.

 
#ifndef CSCI441_SHADER_PROGRAM_PIPELINE_HPP
#define CSCI441_SHADER_PROGRAM_PIPELINE_HPP
 
#include "LogUtils.hpp"
#include "ShaderProgram.hpp"
 
#include <cstdio>
 
 
namespace CSCI441 {
 
    class [[maybe_unused]] ShaderProgramPipeline final {
    public:
        [[maybe_unused]] static void enableDebugMessages();
        [[maybe_unused]] static void disableDebugMessages();
 
        ShaderProgramPipeline();
        ~ShaderProgramPipeline();
 
        ShaderProgramPipeline(const ShaderProgramPipeline&) = delete;
        ShaderProgramPipeline& operator=(const ShaderProgramPipeline&) = delete;
 
        ShaderProgramPipeline(ShaderProgramPipeline&&) noexcept;
        ShaderProgramPipeline& operator=(ShaderProgramPipeline&&) noexcept;
 
        [[maybe_unused]] void useProgramStages( GLbitfield programStages, const ShaderProgram *shaderProgram ) const;
 
        [[maybe_unused]] void useProgramStages( const ShaderProgram *shaderProgram ) const;
 
        [[maybe_unused]] void bindPipeline() const;
 
        [[maybe_unused]] void printPipelineInfo() const;
 
        [[maybe_unused]] [[nodiscard]] bool validatePipeline() const;
 
    private:
        static bool sDEBUG;
 
        GLuint _pipelineHandle;
    };
}
 
 
inline bool CSCI441::ShaderProgramPipeline::sDEBUG = true;
 
[[maybe_unused]]
inline void CSCI441::ShaderProgramPipeline::enableDebugMessages() {
    sDEBUG = true;
}
 
[[maybe_unused]]
inline void CSCI441::ShaderProgramPipeline::disableDebugMessages() {
    sDEBUG = false;
}
 
inline CSCI441::ShaderProgramPipeline::ShaderProgramPipeline() : _pipelineHandle(0) {
    glGenProgramPipelines(1,& _pipelineHandle);
}
 
inline CSCI441::ShaderProgramPipeline::~ShaderProgramPipeline() {
    glDeleteProgramPipelines(1, &_pipelineHandle);
}
 
inline CSCI441::ShaderProgramPipeline::ShaderProgramPipeline(ShaderProgramPipeline&& src) noexcept {
    _pipelineHandle = src._pipelineHandle;
    src._pipelineHandle = 0;
}
 
inline CSCI441::ShaderProgramPipeline &CSCI441::ShaderProgramPipeline::operator=(ShaderProgramPipeline&& src) noexcept {
    // guard against self movement
    if (this != &src) {
        // delete our existing pipeline
        glDeleteProgramPipelines(1, &_pipelineHandle);
        // move the source pipeline
        _pipelineHandle = src._pipelineHandle;
        src._pipelineHandle = 0;
    }
    // return ourselves
    return *this;
}
 
 
[[maybe_unused]]
inline void CSCI441::ShaderProgramPipeline::useProgramStages( const GLbitfield programStages, const ShaderProgram * const shaderProgram ) const {
    glUseProgramStages( _pipelineHandle, programStages, shaderProgram->getShaderProgramHandle() );
}
 
[[maybe_unused]]
inline void CSCI441::ShaderProgramPipeline::useProgramStages( const ShaderProgram * const shaderProgram ) const {
    glUseProgramStages( _pipelineHandle, shaderProgram->getProgramStages(), shaderProgram->getShaderProgramHandle() );
}
 
[[maybe_unused]]
inline void CSCI441::ShaderProgramPipeline::bindPipeline() const {
    glUseProgram(0);    // un-use any existing program that may have previously been used.  programs override pipelines
    glBindProgramPipeline( _pipelineHandle );
}
 
[[maybe_unused]]
inline void CSCI441::ShaderProgramPipeline::printPipelineInfo() const {
    if( sDEBUG ) {
        CSCI441::LogUtils::log("\n[INFO]: /--------------------------------------------------------\\\n");
        CSCI441::LogUtils::log("[INFO]: | Program Pipeline:                                      |\n");
        CSCI441::LogUtils::log("[INFO]: |   Pipeline Handle: %4u %32c\n", _pipelineHandle, '|' );
                
        CSCI441_INTERNAL::ShaderUtils::printProgramPipelineLog(_pipelineHandle);
        
        CSCI441::LogUtils::log("[INFO]: >--------------------------------------------------------<\n");
 
        GLint vs, tcs, tes, gs, fs, cs;
        glGetProgramPipelineiv( _pipelineHandle, GL_VERTEX_SHADER, &vs );
        glGetProgramPipelineiv( _pipelineHandle, GL_TESS_CONTROL_SHADER, &tcs );
        glGetProgramPipelineiv( _pipelineHandle, GL_TESS_EVALUATION_SHADER, &tes );
        glGetProgramPipelineiv( _pipelineHandle, GL_GEOMETRY_SHADER, &gs );
        glGetProgramPipelineiv( _pipelineHandle, GL_FRAGMENT_SHADER, &fs );
 
        GLint major, minor;
        glGetIntegerv(GL_MAJOR_VERSION, &major);
        glGetIntegerv(GL_MINOR_VERSION, &minor);
 
        if(major > 4 || (major == 4 && minor >= 3)) {
            glGetProgramPipelineiv( _pipelineHandle, GL_COMPUTE_SHADER, &cs );
        }
        
        if( vs != 0 )  CSCI441::LogUtils::log("[INFO]: |   Vertex    Shader Program Handle: %2d                  |\n", vs );
        if( tcs != 0 ) CSCI441::LogUtils::log("[INFO]: |   Tess Ctrl Shader Program Handle: %2d                  |\n", tcs );
        if( tes != 0 ) CSCI441::LogUtils::log("[INFO]: |   Tess Eval Shader Program Handle: %2d                  |\n", tes );
        if( gs != 0 )  CSCI441::LogUtils::log("[INFO]: |   Geometry  Shader Program Handle: %2d                  |\n", gs );
        if( fs != 0 )  CSCI441::LogUtils::log("[INFO]: |   Fragment  Shader Program Handle: %2d                  |\n", fs );
        if(major < 4 || (major == 4 && minor >= 3)) {
            if( cs != 0 )  CSCI441::LogUtils::log("[INFO]: |   Compute   Shader Program Handle: %2d                  |\n", cs );
        }
 
        CSCI441::LogUtils::log("[INFO]: \\--------------------------------------------------------/\n");
        CSCI441::LogUtils::log("\n");
    }
}
 
[[maybe_unused]]
inline bool CSCI441::ShaderProgramPipeline::validatePipeline() const {
    glValidateProgramPipeline(_pipelineHandle);
    GLint validateStatus;
    glGetProgramPipelineiv(_pipelineHandle, GL_VALIDATE_STATUS, &validateStatus);
    return (validateStatus == GL_TRUE);
}
 
#endif// CSCI441_SHADER_PROGRAM_PIPELINE_HPP