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 = { 0.0f, 0.0f, 1.0f };
            rgba default_color = { 1.0f };
            float default_depth_offset = 0.0f;
            float default_line_width = 1.0f;

            bool blend_lines = false;
 
            // vertex shader uniforms

            rgba halo_color = { 0.0f, 0.0f, 0.0f, 1.0f };
            float halo_width_in_pixel = 0.0f;
            float percentual_halo_width = 0.0f;
            bool screen_aligned = true;
 
            // geometry shader uniforms

            bool measure_line_width_in_pixel = true;
            float reference_line_width = 0.001f;
            float blend_width_in_pixel = 0.0f;
 
            // fragment shader uniforms

            float halo_color_strength = 1.0f;
        };

        class CGV_API line_renderer : public group_renderer
        {
        protected:
            bool has_normals = false;
            bool has_line_widths = false;
            bool has_depth_offsets = false;
            std::string get_default_prog_name() const override { return "line.glpr"; }
            render_style* create_render_style() const override { return new line_render_style(); }
        public:
            bool enable(context& ctx) override;
            bool disable(context& ctx) override;
            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 init(context& ctx) override;
            template <typename T>
            void set_normal(const context& ctx, const cgv::math::fvec<T,3>& normal) { has_normals = true;  ref_prog().set_attribute(ctx, get_prog_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, "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, "normal", normals, nr_elements, stride_in_bytes); }
            void remove_normal_array(const context& ctx);
            template <typename T>
            void set_line_width(const context& ctx, const T& line_width) { has_line_widths = true;  ref_prog().set_attribute(ctx, get_prog_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, "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, "line_width", line_widths, nr_elements, stride_in_bytes); }
            void remove_line_width_array(const context& ctx);
            template <typename T>
            void set_depth_offset(const context& ctx, const T& depth_offset) { has_depth_offsets = true;  ref_prog().set_attribute(ctx, get_prog_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, "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, "depth_offset", depth_offsets, nr_elements, stride_in_bytes); }
            void remove_depth_offset_array(const 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) override;
        };

        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>