shader_program.h

#pragma once
 
#include <set>
#include "element_traits.h"
#include "shader_code.h"
#include "textured_material.h"
 
namespace cgv {
    namespace media {
        namespace illum {
            struct surface_material;
            class light_source;
        }
    }
}
 
#include "lib_begin.h"
 
namespace cgv {
    namespace utils {
        struct line;
    }
    namespace render {
 
 
class CGV_API shader_program : public shader_program_base
{
protected:
    static std::map<std::string, std::string> program_file_cache;
    static std::map<std::string, std::vector<std::string>> files_cache;
 
    bool show_code_errors : 1;
    bool linked : 1;
    bool state_out_of_date : 1;
    int  nr_attached_geometry_shaders : 13;
 
    std::vector<shader_code*> managed_codes;
 
    bool attach_files(const context& ctx, const std::vector<std::string>& file_names, const shader_compile_options& options = {});
    void update_state(const context& ctx);
    static bool open_program_file(std::string& file_name, bool use_cache, std::string& content, std::vector<cgv::utils::line>& lines, std::string* last_error_ptr = 0);
public:
    
    static bool collect_files_from_cache(const std::string& name, std::vector<std::string>& file_names, bool& added_files);
 
    static bool collect_file(const std::string& file_name, bool use_cache, std::vector<std::string>& file_names);
    static bool collect_files(const std::string& base_name, bool use_cache, std::vector<std::string>& file_names);
    static bool collect_dir(const std::string& dir_name, bool recursive, std::vector<std::string>& file_names);
    static bool collect_program(const std::string& file_name, bool use_cache, std::vector<std::string>& file_names);
    static unsigned int get_max_nr_geometry_shader_output_vertices(const context& ctx);
    shader_program(bool _show_code_errors = false);
    ~shader_program();
    bool create(const context& ctx);
    void destruct(const context& ctx);
    bool attach_code(const context& ctx, const shader_code& code);
    bool detach_code(const context& ctx, const shader_code& code);
    bool attach_code(const context& ctx, const std::string& source, ShaderType st);
    bool attach_file(const context& ctx, const std::string& file_name, ShaderType st = ST_DETECT, const shader_compile_options& options = {});
    bool attach_files(const context& ctx, const std::string& base_name, const shader_compile_options& options = {});
    bool attach_dir(const context& ctx, const std::string& dir_name, bool recursive, const shader_compile_options& options = {});
    bool attach_program(const context& ctx, std::string file_name, bool show_error = false, const shader_compile_options& options = {});
    static std::vector<shader_compile_options> extract_instances(std::string file_name);
    bool link(const context& ctx, bool show_error = false);
    bool is_linked() const;
    void inspect_program_variables(const context& ctx, cgv::render::ProgramVariableKind kind, std::vector<cgv::render::program_variable_info>& Vs,
        bool get_location = true, bool get_value = true);
    bool build_files(const context& ctx, const std::string& base_name, bool show_error = false);
    bool build_dir(const context& ctx, const std::string& dir_name, bool recursive = false, bool show_error = false);
    bool build_program(const context& ctx, const std::string& file_name, bool show_error = false);
    bool build_files(const context& ctx, const std::string& base_name, const shader_compile_options& options, bool show_error = false);
    bool build_dir(const context& ctx, const std::string& dir_name, const shader_compile_options& options, bool recursive = false, bool show_error = false);
    bool build_program(const context& ctx, const std::string& file_name, const shader_compile_options& options, bool show_error = false);
    void set_geometry_shader_info(PrimitiveType input_type, PrimitiveType output_type, int max_output_count = 0);
    bool enable(context& ctx);
    bool disable(context& ctx);
    bool is_enabled() const { return shader_program_base::is_enabled; }
    const std::map<std::string, int>& get_uniform_locations() const;
    int get_uniform_location(const context& ctx, const std::string& name) const;
    bool set_material_uniform(const context& ctx, const std::string& name, const cgv::media::illum::surface_material& material, bool generate_error = false);
    bool set_textured_material_uniform(const context& ctx, const std::string& name, const textured_material& material, bool generate_error = false);
    bool set_light_uniform(const context& ctx, const std::string& name, const cgv::media::illum::light_source& light, bool generate_error = false);
    template <typename T>
    bool set_uniform(const context& ctx, const std::string& name, const T& value, bool generate_error = false) {
        int loc = get_uniform_location(ctx, name);
        if (loc == -1) {
            if (generate_error)
                ctx.error(std::string("shader_program::set_uniform() uniform <") + name + "> not found", this);
            return false;
        }
        return ctx.set_uniform_void(*this, loc, element_descriptor_traits<T>::get_type_descriptor(value), element_descriptor_traits<T>::get_address(value));
    }
    template <typename T>
    bool set_uniform_array(const context& ctx, const std::string& name, const T& array) {
        int loc = get_uniform_location(ctx, name);
        if (loc == -1) {
            ctx.error(std::string("shader_program::set_uniform_array() uniform <") + name + "> not found", this);
            return false;
        }
        return ctx.set_uniform_array_void(*this, loc, array_descriptor_traits<T>::get_type_descriptor(array), array_descriptor_traits<T>::get_address(array), array_descriptor_traits<T>::get_nr_elements(array));
    }
    template <typename T>
    bool set_uniform_array(const context& ctx, const std::string& name, const T* array, size_t nr_elements, bool generate_error = false) {
        int loc = get_uniform_location(ctx, name);
        if (loc == -1) {
            if (generate_error)
                ctx.error(std::string("shader_program::set_uniform_array() uniform <") + name + "> not found", this);
            return false;
        }
        return ctx.set_uniform_array_void(*this, loc, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(array[0]), true), array, nr_elements);
    }
    template <typename T>
    bool set_uniform(const context& ctx, int loc, const T& value) {
        return ctx.set_uniform_void(*this, loc, element_descriptor_traits<T>::get_type_descriptor(value), element_descriptor_traits<T>::get_address(value));
    }
    template <typename T>
    bool set_uniform_array(const context& ctx, int loc, const T& array) {
        return ctx.set_uniform_array_void(*this, loc, array_descriptor_traits<T>::get_type_descriptor(array), array_descriptor_traits<T>::get_address(array), array_descriptor_traits<T>::get_nr_elements(array));
    }
    template <typename T>
    bool set_uniform_array(const context& ctx, int loc, const T* array, size_t nr_elements) {
        return ctx.set_uniform_array_void(*this, loc, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(array), true), array, nr_elements);
    }
    bool set_uniform(const context& ctx, int loc, type_descriptor value_type, const void* value_ptr) {
        return ctx.set_uniform_void(*this, loc, value_type, value_ptr);
    }
    int get_attribute_location(const context& ctx, const std::string& name) const;
    template <typename T>
    bool set_attribute(const context& ctx, const std::string& name, const T& value) {
        int loc = ctx.get_attribute_location(*this, name);
        if (loc == -1) {
            ctx.error(std::string("shader_program::set_attribute() attribute <") + name + "> not found", this);
            return false;
        }
        return ctx.set_attribute_void(*this, loc, element_descriptor_traits<T>::get_type_descriptor(value), element_descriptor_traits<T>::get_address(value));
    }
    template <typename T>
    bool set_attribute(const context& ctx, int loc, const T& value) {
        if (loc == -1) {
            ctx.error("shader_program::set_attribute() called with loc=-1", this);
            return false;
        }
        return ctx.set_attribute_void(*this, loc, element_descriptor_traits<T>::get_type_descriptor(value), element_descriptor_traits<T>::get_address(value));
    }
};
 
    }
}
 
#include <cgv/config/lib_end.h>