line_renderer.h

#pragma once
 
#include "group_renderer.h"
#include <cgv/media/color.h>
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
        namespace render { // @<
 
                struct CGV_API line_render_style : public group_render_style
                {
                        // default values for program attributes
 
                        vec3 default_normal;
                        rgba default_color;
                        float default_depth_offset;
                        float default_line_width;
 
                        // influence on opengl state
                        bool blend_lines;
                protected:
                        friend class line_renderer;
                        mutable GLboolean is_blend;
                        mutable GLint blend_src, blend_dst;
                public:
                        // vertex shader uniforms
 
                        rgba  halo_color;
                        float halo_width_in_pixel;
                        float percentual_halo_width;
                        bool screen_aligned;
 
                        // geometry shader uniforms
 
                        bool measure_line_width_in_pixel;
                        float reference_line_width;
                        float blend_width_in_pixel;
 
                        // fragment shader uniforms
 
                        float halo_color_strength;
                        line_render_style();
                };
 
                class CGV_API line_renderer : public group_renderer
                {
                protected:
                        bool has_normals;
                        bool has_line_widths;
                        bool has_depth_offsets;
                        render_style* create_render_style() const;
                public:
                        line_renderer();
                        bool enable(context& ctx);
                        bool disable(context& ctx);
                        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);
                        template <typename T>
                        void set_normal(const context& ctx, const cgv::math::fvec<T,3>& normal) { has_normals = true;  ref_prog().set_attribute(ctx, ref_prog().get_attribute_location(ctx, "normal"), normal); }
                        template <typename T>
                        void set_normal_array(const context& ctx, const std::vector<T>& normals) { has_normals = true;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "normal"), normals); }
                        template <typename T>
                        void set_normal_array(const context& ctx, const T* normals, size_t nr_elements, unsigned stride_in_bytes = 0) { has_normals = true;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "normal"), normals, nr_elements, stride_in_bytes); }
                        template <typename T>
                        void set_line_width(const context& ctx, const T& line_width) { has_line_widths = true;  ref_prog().set_attribute(ctx, ref_prog().get_attribute_location(ctx, "line_width"), line_width); }
                        template <typename T>
                        void set_line_width_array(const context& ctx, const std::vector<T>& line_widths) { has_line_widths = true;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "line_width"), line_widths); }
                        template <typename T>
                        void set_line_width_array(const context& ctx, const T* line_widths, size_t nr_elements, unsigned stride_in_bytes = 0) { has_line_widths = true;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "line_width"), line_widths, nr_elements, stride_in_bytes); }
                        template <typename T>
                        void set_depth_offset(const context& ctx, const T& depth_offset) { has_depth_offsets = true;  ref_prog().set_attribute(ctx, ref_prog().get_attribute_location(ctx, "depth_offset"), depth_offset); }
                        template <typename T>
                        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>
                        void set_depth_offset_array(const context& ctx, const T* depth_offsets, size_t nr_elements, unsigned stride_in_bytes = 0) { has_depth_offsets = true;  set_attribute_array(ctx, ref_prog().get_attribute_location(ctx, "depth_offset"), depth_offsets, nr_elements, stride_in_bytes); }
                        void draw(context& ctx, size_t start, size_t count,
                                bool use_strips = false, bool use_adjacency = false, uint32_t strip_restart_index = -1);
                };
                extern CGV_API line_renderer& ref_line_renderer(context& ctx, int ref_count_change = 0);
                struct CGV_API line_render_style_reflect : public line_render_style
                {
                        bool self_reflect(cgv::reflect::reflection_handler& rh);
                };
                extern CGV_API cgv::reflect::extern_reflection_traits<line_render_style, line_render_style_reflect> get_reflection_traits(const line_render_style&);
        }
}
 
#include <cgv/config/lib_end.h>