shader_program.h

/********************************************************************
 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
 * https://3d.bk.tudelft.nl/liangliang/
 *
 * This file is part of Easy3D. If it is useful in your research/work,
 * I would be grateful if you show your appreciation by citing it:
 * ------------------------------------------------------------------
 *      Liangliang Nan.
 *      Easy3D: a lightweight, easy-to-use, and efficient C++ library
 *      for processing and rendering 3D data.
 *      Journal of Open Source Software, 6(64), 3255, 2021.
 * ------------------------------------------------------------------
 *
 * Easy3D is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License Version 3
 * as published by the Free Software Foundation.
 *
 * Easy3D is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program. If not, see <http://www.gnu.org/licenses/>.
 ********************************************************************/
 
#ifndef EASY3D_RENDERER_SHADER_PROGRAM_H
#define EASY3D_RENDERER_SHADER_PROGRAM_H
 
#include <unordered_map>
#include <vector>
#include <string>
 
 
namespace easy3d {
 
 
    class ShaderProgram
    {
    public:
 
        // Types of Vertex Attributes
        enum AttribType {
            POSITION,
            COLOR,
            NORMAL,
            TEXCOORD
        };
        typedef std::pair<ShaderProgram::AttribType, std::string> Attribute;
 
        // Types of Shaders
        enum ShaderType {
            VERTEX,
            FRAGMENT,
            GEOMETRY,
            TESS_CONTROL,
            TESS_EVALUATION,
            COMPUTE,
            NUM_SHADER_TYPES
        };
 
        static bool is_supported();
 
        explicit ShaderProgram(const std::string& name = "unknown");
        ~ShaderProgram();
 
        void set_name(const std::string& name) { name_ = name; }
        const std::string& name() const { return name_; }
 
        void set_verbose(bool v) { verbose_ = v; }
 
        // ---------------------------------------------------------------
 
        unsigned int get_program() const;
 
        void clear();
 
        //---------------------- Creation ---------------------------
 
        bool load_shader_from_file(ShaderType st, const std::string& file_name, const std::string& inc_id = "#include");
 
        bool load_shader_from_code(ShaderType st, const std::string& code);
 
        void set_attrib_name(ShaderProgram::AttribType at, const std::string& name) const;
        void set_attrib_names(const std::vector<ShaderProgram::Attribute>& attributes) const;
 
        bool link_program();
 
        void set_program_output(int index, const std::string& name) const;
 
        int program_output(const std::string& name) const;
 
        //---------------------- Rendering ---------------------------
 
        void bind() const;
 
        // generic function to set the uniform <name> to value
        // NOTE: if your uniform is an array type, be careful to use the correct uniform names. For example, you have 
        //       'uniform vec2/float values[8]' in your shader code, the uniform name is 'values[0]' (not 'values').    
        //       So calling to this function looks like: program->set_uniform("values[0]", valueArray);
        ShaderProgram* set_uniform(const std::string& name, const void *value);
 
        // For int and bool uniforms. Sets the uniform <name> to the int value
        ShaderProgram* set_uniform(const std::string& name, int value);
 
        // For unsigned int uniforms. Sets the uniform <name> to the unsigned int value
        ShaderProgram* set_uniform(const std::string& name, unsigned int value);
 
        // For float uniforms. Sets the uniform <name> to the float value
        ShaderProgram* set_uniform(const std::string& name, float value);
 
        ShaderProgram* set_block(const std::string& name, const void *value);
 
        ShaderProgram* set_block_uniform(const std::string& blockName, const std::string& uniformName, const void *value);
 
        ShaderProgram* set_block_uniform_array_element(const std::string& blockName, const std::string& uniformName, int arrayIndex, const void* value);
 
        // tex_target: GL_TEXTURE_2D, GL_TEXTURE_2D_MULTISAMPLE, GL_TEXTURE_2D_ARRAY
        // default value is GL_TEXTURE_2D (0x0DE1, just to eliminate the inclusion of gl header file).
        ShaderProgram* bind_texture(const std::string& name, unsigned int tex_id, int unit, unsigned int tex_target = 0x0DE1);
        ShaderProgram* release_texture(unsigned int tex_target = 0x0DE1);
 
        void release() const;
 
        // ---------------------- Other info -------------------------------
 
        int get_attribute_location(const std::string& name) const;
 
        // methods to inquire as to what uniforms/attributes are used by this shader. This can 
        // save some compute time if the uniforms or attributes are expensive to compute.
        // Note: the program must be compiled and linked.
        bool is_uniform_used(const std::string& name);
        bool is_attribute_used(const std::string& name);
 
        // returns GL_VALIDATE_STATUS for the program 
        // glValidateProgram() is meant to be called directly before a draw call (i.e., glDraw*())
        // with that shader bound and all the bindings (VAO, textures) set. Its purpose is to ensure
        // that the shader can execute given the current GL state.
        bool is_program_valid() const;
 
        bool is_program_linked() const;
 
        bool is_bound() const;
 
        // return true if shader compilation was successfully, false otherwise. 
        // 'log' returns the shader's infolog
        bool shader_info_log(std::string& log, unsigned int shader) const;
 
        // return true if program linkage was successfully, false otherwise. 
        // 'log' returns the program's infolog
        bool program_info_log(std::string& log) const;
 
        // useful for debug. More detailed version are implemented in OpenglInfo class.
        // NOTE: require OpenGL >= 4.3
        void print_active_attributes();
        void print_active_uniforms();
        void print_active_uniform_blocks();
 
        // ---------------------- Load/Save binary -------------------------------
        // The ready-to-use (i.e., compiled and linked) program in a single binary file.
        // NOTE: require OpenGL >= 4.1
        bool load_binary(const std::string& file_name);
        bool save_binary(const std::string& file_name);
 
        // aux function to read the shader's source code from a file
        static std::string load_shader_source(const std::string& file_name, const std::string& inc_id = "#include");
 
    protected:
 
        // AUX STRUCTURES
 
        // stores information for uniforms
        struct Uniform {
            std::string  name;
            unsigned int type;
            int location;
            int size;
            unsigned int stride;
        };
 
        // stores information for block uniforms
        struct BlockUniform {
            std::string name;
            unsigned int type;
            unsigned int offset;
            unsigned int size;
            unsigned int arrayStride;
        };
 
        // Uniform blocks are a very convenient feature for two reasons :
        //  (1) Allow uniform sharing between programs �C set once, use many times
        //  (2) Allow setting multiple values at once
        struct UniformBlock { // stores information for a block and its uniforms
            std::string name;
            // size of the uniform block
            int size;
            // buffer bound to the index point
            unsigned int buffer;
            // binding index
            unsigned int bindingIndex;
            // uniforms information
            // maps of std::string can be super slow when calling find with a string literal or const char* 
            // as find forces construction/copy/destruction of a std::sting copy of the const char*.
            std::unordered_map<std::string, BlockUniform> uniformOffsets;
        };
 
        // VARIABLES
 
        // blockCount is used to assign binding indexes
        static int spBlockCount;
 
        // Stores info on all blocks found
        // maps of std::string can be super slow when calling find with a string literal or const char* 
        // as find forces construction/copy/destruction of a std::sting copy of the const char*.
        static std::unordered_map<std::string, UniformBlock> spBlocks;
 
        // stores the OpenGL shader types
        static unsigned int spGLShaderTypes[ShaderProgram::NUM_SHADER_TYPES];
 
        // stores the text string related to each type
        static std::string spStringShaderTypes[ShaderProgram::NUM_SHADER_TYPES];
 
        // the program handle
        unsigned int program_;
 
        // stores info on the uniforms
        // maps of std::string can be super slow when calling find with a string literal or const char* 
        // as find forces construction/copy/destruction of a std::sting copy of the const char*.
        std::unordered_map<std::string, Uniform> pUniforms;
 
        // AUX FUNCTIONS
 
        // aux function to get info on the uniforms referenced by the shaders
        void _add_uniforms();
 
        // aux function to store the info of a uniform
        void _add_uniform(const std::string& name, unsigned int type, unsigned int size);
 
        // aux function to get info on the blocks referenced by the shaders
        void _add_blocks();
 
        // aux function to determine the size in bytes based on the OpenGL type
        int _type_size(unsigned int type) const;
 
        std::string _type_string(unsigned int type) const;
 
        // aux function to read a previously compiled and linked program code from a file
        std::string _read_linked_program(const std::string& file);
 
    private:
        std::string name_;
        bool verbose_; // log any issues found
 
        //copying disabled
        ShaderProgram(const ShaderProgram&);
        ShaderProgram& operator=(const ShaderProgram&);
 
    private:
        friend class ShaderManager;
    };
 
}
 
 
#endif  // EASY3D_RENDERER_SHADER_PROGRAM_H