group_renderer.h

#pragma once
 
#include "renderer.h"
#include <cgv/reflect/reflect_extern.h>
#include <cgv/render/shader_program.h>
#include <cgv_reflect_types/render/context.h>
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<

        struct CGV_API group_render_style : public render_style
        {
            bool use_group_color = false;
            bool use_group_transformation = false;
            int max_nr_groups = 8;
        };

        class CGV_API group_renderer : public renderer
        {
        protected:
            bool has_group_indices = false;
            bool has_group_colors = false;
            bool has_group_translations = false;
            bool has_group_rotations = false;
            void update_shader_program_options(shader_compile_options& options) const override;
        public:
            void enable_attribute_array_manager(const context& ctx, attribute_array_manager& aam) override;
            void disable_attribute_array_manager(const context& ctx, attribute_array_manager& aam) override;
            bool validate_attributes(const context& ctx) const override;
            bool enable(context& ctx) override;
            bool disable(context& ctx) override;
            void set_group_index_array(const context& ctx, const std::vector<unsigned>& group_indices);
            void set_group_index_array(const context& ctx, const unsigned* group_indices, size_t nr_elements);
            void set_group_index_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_group_index_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_group_index_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_group_index_array(const context& ctx);
            template <typename T>
            void set_group_colors(const context& ctx, const std::vector<T>& colors) { has_group_colors = true;  ref_prog().set_uniform_array(ctx, "group_colors", colors); }
            template <typename T>
            void set_group_colors(const context& ctx, const T* colors, size_t nr_elements) { has_group_colors = true;  ref_prog().set_uniform_array(ctx, "group_colors", colors, nr_elements); }
            template <typename T>
            void set_group_translations(const context& ctx, const std::vector<T>& group_translations) { has_group_translations = true; ref_prog().set_uniform_array(ctx, "group_translations", group_translations); }
            template <typename T>
            void set_group_translations(const context& ctx, const T* group_translations, size_t nr_elements) { has_group_translations = true; ref_prog().set_uniform_array(ctx, "group_translations", group_translations, nr_elements); }
            template <typename T>
            void set_group_rotations(const context& ctx, const std::vector<T>& group_rotations) { has_group_rotations = true; ref_prog().set_uniform_array(ctx, "group_rotations", group_rotations); }
            template <typename T>
            void set_group_rotations(const context& ctx, const T* group_rotations, size_t nr_elements) { has_group_rotations = true; ref_prog().set_uniform_array(ctx, "group_rotations", group_rotations, nr_elements); }
        };
 
        struct CGV_API group_render_style_reflect : public group_render_style
        {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
        extern CGV_API cgv::reflect::extern_reflection_traits<group_render_style, group_render_style_reflect> get_reflection_traits(const group_render_style&);
 
    }
}
 
 
//namespace cgv {
//  namespace reflect {
//      namespace render {
//      }
//  }
//}
 
 
#include <cgv/config/lib_end.h>