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:
        enum AttribType {
            POSITION,   
            COLOR,     
            NORMAL,       
            TEXCOORD    
        };

        typedef std::pair<AttribType, std::string> Attribute;

        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;

        ShaderProgram* set_uniform(const std::string& name, const void *value);

        ShaderProgram* set_uniform(const std::string& name, int value);

        ShaderProgram* set_uniform(const std::string& name, unsigned int 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);

        // 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;

        bool is_uniform_used(const std::string& name);

        bool is_attribute_used(const std::string& name);

        bool is_program_valid() const;

        bool is_program_linked() const;

        bool is_bound() const;

        bool shader_info_log(std::string& log, unsigned int shader) const;

        bool program_info_log(std::string& log) const;

        void print_active_attributes();
        void print_active_uniforms();
        void print_active_uniform_blocks();
 
        // ---------------------- Load/Save binary -------------------------------
        bool load_binary(const std::string& file_name);
        bool save_binary(const std::string& file_name);

        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