point_renderer.h

#pragma once
 
#include "group_renderer.h"
 
#include "gl/lib_begin.h"
 
namespace cgv {
        namespace render {
                class CGV_API point_renderer;
 
 
                extern CGV_API point_renderer& ref_point_renderer(context& ctx, int ref_count_change = 0);
 
                struct CGV_API point_render_style : public group_render_style
                {
                        /*@name point rendering attributes*/
                        float point_size;
                        bool use_group_point_size;
                        bool measure_point_size_in_pixel;
                        bool screen_aligned;
 
                        /*@name global point rendering options*/
                        float default_depth_offset;
                        float blend_width_in_pixel;
                        float halo_width_in_pixel;
                        float percentual_halo_width;
                        rgba halo_color;
                        float halo_color_strength;
                        bool blend_points;
                        point_render_style();
                };
 
                class CGV_API point_renderer : public group_renderer
                {
                protected:
                        bool has_point_sizes;
                        bool has_group_point_sizes;
                        bool has_indexed_colors;
                        bool has_depth_offsets;
                        float reference_point_size;
                        float y_view_angle;
                        render_style* create_render_style() const;
                public:
                        point_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);
                        bool init(context& ctx);
                        void set_reference_point_size(float _reference_point_size);
                        void set_y_view_angle(float y_view_angle);
                        template <typename T = float>
                        void set_point_size_array(const context& ctx, const std::vector<T>& point_sizes) { has_point_sizes = true; set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "point_size"), point_sizes); }
                        template <typename T = float>
                        void set_depth_offset_array(const context& ctx, const std::vector<T>& depth_offsets) { has_depth_offsets = true; set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "depth_offset"), depth_offsets); }
                        template <typename T = unsigned, typename C = cgv::media::color<float,cgv::media::RGB,cgv::media::OPACITY> >
                        void set_indexed_color_array(const context& ctx, const std::vector<T>& color_indices, const std::vector<C>& palette) {
                                has_indexed_colors = true; 
                                set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "color_index"), color_indices); 
                                ref_prog().set_uniform_array(ctx, "palette", palette); 
                        }
                        template <typename T = float>
                        void set_group_point_sizes(const context& ctx, const std::vector<T>& group_point_sizes) { has_group_point_sizes = true; ref_prog().set_uniform_array(ctx, "group_point_sizes", group_point_sizes); }
                        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 point_render_style_reflect : public point_render_style
                {
                        bool self_reflect(cgv::reflect::reflection_handler& rh);
                };
                extern CGV_API cgv::reflect::extern_reflection_traits<point_render_style, point_render_style_reflect> get_reflection_traits(const point_render_style&);
        }
}
 
#include <cgv/config/lib_end.h>