arrow_renderer.h

#pragma once
 
#include "surface_renderer.h"
 
#include "gl/lib_begin.h"
 
namespace cgv {
        namespace render {
                class CGV_API arrow_renderer;
 
 
                extern CGV_API arrow_renderer& ref_arrow_renderer(context& ctx, int ref_count_change = 0);
 
                struct CGV_API arrow_render_style : public surface_render_style
                {
                        /*@name arrow rendering attributes*/
                        float radius_lower_bound;
                        float radius_relative_to_length;
                        float head_radius_scale;
                        float head_length_relative_to_radius;
                        float head_length_relative_to_length;
                        float length_scale;
                        float color_scale;
                        bool normalize_length;
                        float relative_location_of_position;
                        float length_eps;
                        float inner_outer_lambda;
                        int nr_subdivisions;
                        arrow_render_style();
                };
 
                class CGV_API arrow_renderer : public surface_renderer
                {
                protected:
                        bool has_directions;
                        bool position_is_center;
                        bool direction_is_end_point;
                        render_style* create_render_style() const;
                public:
                        arrow_renderer();
                        void enable_attribute_array_manager(const context& ctx, attribute_array_manager& aam);
                        void disable_attribute_array_manager(const context& ctx, attribute_array_manager& aam);
                        template <typename T>
                        void set_direction_array(const context& ctx, const std::vector<T>& directions) { has_directions = true;  direction_is_end_point = false;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "direction"), directions); }
                        template <typename T>
                        void set_direction_array(const context& ctx, const T* directions, size_t nr_elements, unsigned stride_in_bytes = 0) { has_directions = true; direction_is_end_point = false; set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "direction"), directions, nr_elements, stride_in_bytes); }
                        template <typename T>
                        void set_end_point_array(const context& ctx, const std::vector<T>& end_points) { has_directions = true;  direction_is_end_point = true;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "direction"), end_points); }
                        template <typename T>
                        void set_end_point_array(const context& ctx, const T* end_points, size_t nr_elements, unsigned stride_in_bytes = 0) { has_directions = true; direction_is_end_point = true; set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "direction"), end_points, nr_elements, stride_in_bytes); }
                        bool init(context& ctx);
                        bool validate_attributes(const context& ctx) const;
                        bool enable(context& ctx);
                        bool disable(context& ctx);
                        void draw(context& ctx, size_t start, size_t count,
                                bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
                };
                struct CGV_API arrow_render_style_reflect : public arrow_render_style
                {
                        bool self_reflect(cgv::reflect::reflection_handler& rh);
                };
                extern CGV_API cgv::reflect::extern_reflection_traits<arrow_render_style, arrow_render_style_reflect> get_reflection_traits(const arrow_render_style&);
        }
}
 
#include <cgv/config/lib_end.h>