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();
 
class shader_compile_options {
public:
    using string_map = std::map<std::string, std::string>;
    
    bool empty() const {
        return defines.empty() && snippets.empty();
    }
 
    void clear() {
        defines.clear();
        snippets.clear();
    }
 
    const string_map& get_macros() const {
        return defines;
    }
 
    const string_map& get_snippets() const {
        return snippets;
    }
 
    void define_macro(const std::string& identifier) {
        defines[identifier] = "";
    }
 
    template<typename T, typename std::enable_if<std::is_arithmetic_v<T>, bool>::type = true>
    void define_macro(const std::string& identifier, const T& value) {
        defines[identifier] = std::to_string(value);
    }
 
    template<typename T, typename std::enable_if<std::is_enum_v<T>, bool>::type = true>
    void define_macro(const std::string& identifier, const T& value) {
        defines[identifier] = std::to_string(static_cast<std::underlying_type_t<T>>(value));
    }
 
    void define_macro(const std::string& identifier, bool value) {
        defines[identifier] = value ? "1" : "0";
    }
 
    void define_macro(const std::string& identifier, const std::string& value) {
        defines[identifier] = value;
    }
 
    template<typename T, typename std::enable_if<std::is_arithmetic_v<T>, bool>::type = true>
    void define_macro_if_not_default(const std::string& identifier, const T& value, const T& default_value) {
        if(value != default_value)
            defines[identifier] = std::to_string(value);
        else
            defines.erase(identifier);
    }
 
    template<typename T, typename std::enable_if<std::is_enum_v<T>, bool>::type = true>
    void define_macro_if_not_default(const std::string& identifier, const T& value, const T& default_value) {
        if(value != default_value)
            defines[identifier] = std::to_string(static_cast<std::underlying_type_t<T>>(value));
        else
            defines.erase(identifier);
    }
 
    void define_macro_if_not_default(const std::string& identifier, bool value, bool default_value) {
        if(value != default_value)
            defines[identifier] = value ? "1" : "0";
        else
            defines.erase(identifier);
    }
 
    void define_macro_if_not_default(const std::string& identifier, const std::string& value, const std::string& default_value) {
        if(value != default_value)
            defines[identifier] = value;
        else
            defines.erase(identifier);
    }
 
    void define_macro_if_true(bool predicate, const std::string& identifier) {
        if(predicate)
            define_macro(identifier, "1");
        else
            undefine_macro(identifier);
    }
 
    void undefine_macro(const std::string& identifier) {
        defines.erase(identifier);
    }
 
    void define_snippet(const std::string& identifier, const std::string& replacement_text) {
        snippets[identifier] = replacement_text;
    }
 
    void undefine_snippet(const std::string& identifier) {
        snippets.erase(identifier);
    }
 
    void extend(const shader_compile_options& other, bool overwrite) {
        if(overwrite) {
            for(const auto& define : other.defines)
                defines[define.first] = define.second;
 
            for(const auto& snippet : other.snippets)
                snippets[snippet.first] = snippet.second;
        } else {
            defines.insert(other.defines.begin(), other.defines.end());
            snippets.insert(other.snippets.begin(), other.snippets.end());
        }
    }
 
    bool operator==(const shader_compile_options& other) const {
        return defines == other.defines && snippets == other.snippets;
    }
 
    bool operator!=(const shader_compile_options& other) const {
        return !(*this == other);
    }
 
private:
    string_map defines;
    string_map snippets;
};
 
class CGV_API shader_code : public render_component
{
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);
    void destruct(const context& ctx);
    bool read_code(const context& ctx, const std::string &file_name, ShaderType st = ST_DETECT, const shader_compile_options& options = {});
    bool set_code(const context& ctx, const std::string &source, ShaderType st);
    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, const shader_compile_options& options = {}, bool show_error = true);
    bool is_compiled() const;
 
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;
 
private:
    static std::string resolve_includes(const std::string& source, bool use_cache, std::set<std::string>& included_file_names, std::string* _last_error = 0);
    static std::string resolve_includes(const std::string& source, bool use_cache, std::string* _last_error = 0);
    static void resolve_version_and_extensions(std::string& source);
    static void set_defines_and_snippets(std::string& source, const shader_compile_options& options);
    static void set_vertex_attrib_locations(std::string& source);
};
 
 
    }
}
 
#include <cgv/config/lib_end.h>