shader_code.h

#pragma once
 
#include <cgv/render/context.h>
#include <set>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace render {
 
struct CGV_API shader_config : public cgv::base::base
{
    std::string shader_path;
    bool trace_file_names;
    bool show_file_paths;
    std::vector<std::string> shader_file_names;
    std::vector<std::string> inserted_shader_file_names;
    shader_config();
    std::string get_type_name() const;
    bool self_reflect(cgv::reflect::reflection_handler& srh);
};
 
typedef cgv::data::ref_ptr<shader_config> shader_config_ptr;
 
extern CGV_API shader_config_ptr get_shader_config();
 
typedef std::map<std::string, std::string> shader_define_map;
 
class CGV_API shader_code : public render_component
{
public:
    template<typename T, typename std::enable_if<!std::is_enum<T>::value, bool>::type = true>
    static void set_define(shader_define_map& defines, const std::string& name, const T& value, const T& default_value) {
        if(value != default_value)
            defines[name] = std::to_string(value);
        else
            defines.erase(name);
    }
    
    template<typename T, typename std::enable_if<std::is_enum<T>::value, bool>::type = true>
    static void set_define(shader_define_map& defines, const std::string& name, const T& value, const T& default_value) {
        if(value != default_value)
            defines[name] = std::to_string((unsigned)value);
        else
            defines.erase(name);
    }
 
    static void set_define(shader_define_map& defines, const std::string& name, const std::string& value, const std::string& default_value) {
        if(value != default_value)
            defines[name] = value;
        else
            defines.erase(name);
    }
 
    static void set_define(shader_define_map& defines, const std::string& name, bool value, bool default_value) {
        if(value != default_value)
            defines[name] = value ? "1" : "0";
        else
            defines.erase(name);
    }
 
protected:
    static std::map<std::string, std::string> shader_file_name_map;
    static bool shader_file_name_map_initialized;
    static std::map<std::string, std::string> code_cache;
 
    ShaderType st;
 
public:
    shader_code();
    ~shader_code();
    static void decode_if_base64(std::string& content);
    static std::string find_file(const std::string& file_name, bool search_exhaustive = false);
    static std::string get_last_error(const std::string& file_name, const std::string& last_error);
    static std::string read_code_file(const std::string &file_name, std::string* _last_error = 0);
    static std::string retrieve_code(const std::string& file_name, bool use_cache, std::string* _last_error);
    static ShaderType detect_shader_type(const std::string& file_name);
    static std::string resolve_includes(const std::string& source, bool use_cache, std::set<std::string>& included_file_names, std::string* _last_error = 0);
    inline static std::string resolve_includes(const std::string& source, bool use_cache, std::string* _last_error = 0) {
        std::set<std::string> dummy;
        return resolve_includes(source, use_cache, dummy, _last_error);
    }
    void destruct(const context& ctx);
    bool read_code(const context& ctx, const std::string &file_name, ShaderType st = ST_DETECT, const shader_define_map& defines = shader_define_map());
    bool set_code(const context& ctx, const std::string &source, ShaderType st);
    void set_defines(std::string& source, const shader_define_map& defines);
    void set_vertex_attrib_locations(std::string& source);
    ShaderType get_shader_type() const;
    bool compile(const context& ctx);
    bool read_and_compile(const context& ctx, const std::string &file_name, ShaderType st = ST_DETECT, bool show_error = true, const shader_define_map& defines = shader_define_map());
    bool is_compiled() const;
};
 
 
    }
}
 
#include <cgv/config/lib_end.h>