renderer.h

#pragma once
 
#include <cgv/render/context.h>
#include <cgv/render/shader_program.h>
#include <cgv_gl/gl/gl_context.h>
 
#include "attribute_array_manager.h"
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<
        
        struct CGV_API render_style
        {
            // Make destructor virtual to allow deletion of inherited class instances through pointer to this base class.
            virtual ~render_style();
        };
        
        class CGV_API renderer
        {
        private:
            shader_program prog;
            shader_program* prog_ptr = &prog;
            shader_compile_options prog_options;
            shader_compile_options last_prog_options;
//#ifdef _DEBUG
            /* TODO: FIXME: Find out why _DEBUG is sometimes not set in CMake Ninja builds under Linux, causing crashes
                            due to inconsistent object layout in memory between different modules using the renderers */
            int current_prog_render_count = 10;
//#endif
            std::set<int> enabled_attribute_arrays;
            mutable render_style* default_render_style = nullptr;
            const render_style* rs = nullptr;
            const void* indices = nullptr;
            const vertex_buffer* index_buffer_ptr = nullptr;
            cgv::type::info::TypeId index_type = cgv::type::info::TI_UNDEF;
            size_t index_count = 0;
            attribute_array_manager default_aam;
            attribute_array_manager* aam_ptr;
        protected:
            bool has_aam() const { return aam_ptr != 0 && aam_ptr != &default_aam; }
            bool has_attribute(const context& ctx, const std::string& name) {
                return aam_ptr->has_attribute(ctx, get_prog_attribute_location(ctx, name, false));
            }
            virtual render_style* create_render_style() const = 0;
            const render_style* get_style_ptr() const;
            bool attributes_persist() const { return has_aam(); }
            virtual void update_shader_program_options(shader_compile_options& options) const {}
            virtual bool build_shader_program(context& ctx, shader_program& prog, const shader_compile_options& options) const;
        public:
            shader_compile_options& ref_shader_options() { return prog_options; }
            shader_program& ref_prog() { return *prog_ptr; }
            void set_prog(shader_program& one_shot_prog);
        protected:
            virtual std::string get_default_prog_name() const = 0;
 
            template <typename T>
            const T& get_style() const { return *static_cast<const T*>(get_style_ptr());  }
            mutable bool has_colors = false;
            mutable bool has_positions = false;
 
            int get_prog_attribute_location(const context& ctx, const std::string & name, bool error_check = true) {
                int loc = ref_prog().get_attribute_location(ctx, name);
#ifdef _DEBUG
                if(loc < 0 && error_check)
                    std::cerr << "Warning: cgv_gl::renderer attribute " << name << " not supported by current shader program" << std::endl;
#endif
                return loc;
            }
 
            template <typename T>
            bool set_attribute_array(const context& ctx, const std::string& name, const T& array) {
                int loc = get_prog_attribute_location(ctx, name);
                if(loc < 0)
                    return false;
                if(aam_ptr)
                    return aam_ptr->set_attribute_array(ctx, loc, array);
                enabled_attribute_arrays.insert(loc);
                return attribute_array_binding::set_global_attribute_array(ctx, loc, array);
            }
            template <typename T>
            bool set_attribute_array(const context& ctx, const std::string& name, const T* array_ptr, size_t nr_elements, unsigned stride) {
                int loc = get_prog_attribute_location(ctx, name);
                if(loc < 0)
                    return false;
                if (aam_ptr)
                    return aam_ptr->set_attribute_array(ctx, loc, array_ptr, nr_elements, stride);
                enabled_attribute_arrays.insert(loc);
                return attribute_array_binding::set_global_attribute_array(ctx, loc, array_ptr, nr_elements, stride);
            }
            bool set_attribute_array(const context& ctx, const std::string& name, type_descriptor element_type, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes);
            //bool set_attribute_array(const context& ctx, int loc, type_descriptor element_type, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes);
            template <typename C, typename T>
            bool set_composed_attribute_array(const context& ctx, const std::string& name, const C* array_ptr, size_t nr_elements, const T& elem) {
                int loc = get_prog_attribute_location(ctx, name);
                if(loc < 0)
                    return false;
                if (aam_ptr)
                    return aam_ptr->set_composed_attribute_array(ctx, loc, array_ptr, nr_elements, elem);
                enabled_attribute_arrays.insert(loc);
                return attribute_array_binding::set_global_attribute_array(ctx, loc, &elem, nr_elements, sizeof(C));
            }
            template <typename C, typename T>
            bool ref_composed_attribute_array(const context& ctx, const std::string& name, const std::string& name_ref, const C* array_ptr, size_t nr_elements, const T& elem) {
                int loc = get_prog_attribute_location(ctx, name);
                int loc_ref = get_prog_attribute_location(ctx, name_ref);
                if(loc < 0 || loc_ref < 0)
                    return false;
                if (aam_ptr)
                    return aam_ptr->ref_composed_attribute_array(ctx, loc, loc_ref, array_ptr, nr_elements, elem);
                enabled_attribute_arrays.insert(loc);
                return attribute_array_binding::set_global_attribute_array(ctx, loc, &elem, nr_elements, sizeof(C));
            }
            bool remove_attribute_array(const context& ctx, const std::string& name);
        public:
            void draw_impl(context& ctx, PrimitiveType pt, size_t start, size_t count, bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
            void draw_impl_instanced(context& ctx, PrimitiveType type, size_t start, size_t count, size_t instance_count, bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
            renderer();
            virtual ~renderer();
            void manage_singleton(context& ctx, const std::string& renderer_name, int& ref_count, int ref_count_change);
            virtual void enable_attribute_array_manager(const context& ctx, attribute_array_manager& aam);
            virtual void disable_attribute_array_manager(const context& ctx, attribute_array_manager& aam);
            DEPRECATED("deprecated, use enable_attribute_array_manager() paired with disable_attribute_manager instead().")
                virtual void set_attribute_array_manager(const context& ctx, attribute_array_manager* _aam_ptr = 0);
            void set_render_style(const render_style& rs);
            bool build_program(context& ctx, shader_program& prog, const render_style& rs);
 
            virtual bool init(context& ctx);
            template <typename T>
            void set_position(const context& ctx, const T& position) { has_positions = true; ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "position"), position); }
            template <typename T>
            void set_position_array(const context& ctx, const std::vector<T>& positions) { has_positions = true; set_attribute_array(ctx, "position", positions); }
            template <typename T>
            void set_position_array(const context& ctx, const T* positions, size_t nr_elements, unsigned stride_in_bytes = 0) { has_positions = true; set_attribute_array(ctx, "position", positions, nr_elements, stride_in_bytes); }
            void set_position_array(const context& ctx, type_descriptor element_type, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes);
            template <typename T>
            void set_position_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_position_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_position_array(const context& ctx);
            template <typename T>
            void set_color(const context& ctx, const T& color) { has_colors = true; ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "color"), color); }
            template <typename T>
            void set_color_array(const context& ctx, const std::vector<T>& colors) { has_colors = true;  set_attribute_array(ctx, "color", colors); }
            template <typename T>
            void set_color_array(const context& ctx, const T* colors, size_t nr_elements, unsigned stride_in_bytes = 0) { has_colors = true;  set_attribute_array(ctx, "color", colors, nr_elements, stride_in_bytes); }
            void set_color_array(const context& ctx, type_descriptor element_type, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0);
            template <typename T>
            void set_color_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_color_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_color_array(const context& ctx);
            template <typename T>
            bool set_indices(const context& ctx, const std::vector<T>& indices, bool keep_on_cpu = false) {
                this->indices = &indices.front();
                index_buffer_ptr = 0;
                index_count = indices.size();
                index_type = cgv::type::info::type_id<T>::get_id();
                if (!keep_on_cpu && aam_ptr)
                    return aam_ptr->set_indices(ctx, indices);
                return true;
            }
            template <typename T>
            bool set_indices(const context& ctx, const T* indices, size_t nr_indices, bool keep_on_cpu = false) {
                this->indices = indices;
                index_buffer_ptr = 0;
                index_count = nr_indices;
                index_type = cgv::type::info::type_id<T>::get_id();
                if (!keep_on_cpu && aam_ptr)
                    return aam_ptr->set_indices(ctx, indices, nr_indices);
                return true;
            }
 
            template <typename T>
            bool set_indices(const context& ctx, const vertex_buffer& vbo, size_t count) { 
                index_buffer_ptr = &vbo;
                indices = 0;
                index_count = count;
                index_type = cgv::type::info::type_id<T>::get_id();
                if (aam_ptr)
                    aam_ptr->remove_indices(ctx);
                return true;
            }
            bool has_indices() const {
                if(aam_ptr && aam_ptr->has_index_buffer())
                    return true;
                return index_count > 0;
            }
            void remove_indices(const context& ctx);
            const vertex_buffer* get_vertex_buffer_ptr(const context& ctx, const attribute_array_manager& aam, const std::string& attr_name) {
                return aam.get_buffer_ptr(get_prog_attribute_location(ctx, attr_name));
            }
            const vertex_buffer* get_index_buffer_ptr(const attribute_array_manager& aam) {
                return aam.get_buffer_ptr(-1);
            }
            virtual bool validate_attributes(const context& ctx) const;
            bool validate_and_enable(context& ctx);
 
            virtual bool enable(context& ctx);
 
            virtual void draw(context& ctx, size_t start, size_t count,
                bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
            virtual bool disable(context& ctx);
 
            virtual bool render(context& ctx, size_t start, size_t count, 
                bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
            virtual void clear(const context& ctx);
        };
    }
}
 
#include <cgv/config/lib_end.h>