box_renderer.h

#pragma once
 
#include "surface_renderer.h"
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<
        class CGV_API box_renderer;


        extern CGV_API box_renderer& ref_box_renderer(context& ctx, int ref_count_change = 0);

        struct CGV_API box_render_style : public surface_render_style
        {
            vec3 default_extent = { 1.0f };
            vec3 relative_anchor = { 0.0f };
            bool rounding = false;
            float default_radius = 0.01f;
        };

        class CGV_API box_renderer : public surface_renderer
        {
        protected:
            bool has_extents = false;
            bool has_radii = false;
            bool has_secondary_colors = false;
            bool has_translations = false;
            bool has_rotations = false;
            bool position_is_center = true;

            std::string get_default_prog_name() const override { return "box.glpr"; }
            render_style* create_render_style() const override { return new box_render_style(); }
            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;
            void set_position_is_center(bool _position_is_center);
            bool enable(context& ctx) override;
            template <typename T>
            void set_extent(const context& ctx, const T& extent) { has_extents = true; ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "extent"), extent); }
            template <typename T>
            void set_extent_array(const context& ctx, const std::vector<T>& extents) { has_extents = true;  set_attribute_array(ctx, "extent", extents); }
            template <typename T>
            void set_extent_array(const context& ctx, const T* extents, size_t nr_elements, unsigned stride_in_bytes = 0) { has_extents = true;  set_attribute_array(ctx, "extent", extents, nr_elements, stride_in_bytes); }
            void remove_extent_array(const context& ctx);
            template <typename T = float>
            void set_radius(const context& ctx, const T& radius) { has_radii = true; ref_prog().set_attribute(ctx, ref_prog().get_attribute_location(ctx, "radius"), radius); }
            template <typename T = float>
            void set_radius_array(const context& ctx, const std::vector<T>& radii) { has_radii = true; set_attribute_array(ctx, "radius", radii); }
            template <typename T = float>
            void set_radius_array(const context& ctx, const T* radii, size_t nr_elements, unsigned stride_in_bytes = 0) { has_radii = true;  set_attribute_array(ctx, "radius", radii, nr_elements, stride_in_bytes); }
            void remove_radius_array(const context& ctx);
            template <typename T>
            void set_secondary_color(const context& ctx, const T& color) { has_secondary_colors = true; ref_prog().set_attribute(ctx, "secondary_color", color); }
            template <typename T>
            void set_secondary_color_array(const context& ctx, const std::vector<T>& colors) { has_secondary_colors = true;  set_attribute_array(ctx, "secondary_color", colors); }
            template <typename T>
            void set_secondary_color_array(const context& ctx, const T* colors, size_t nr_elements, unsigned stride_in_bytes = 0) { has_secondary_colors = true;  set_attribute_array(ctx, "secondary_color", colors, nr_elements, stride_in_bytes); }
            void set_secondary_color_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_secondary_color_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_secondary_color_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_secondary_color_array(const context& ctx);
            template <typename T>
            void set_box(const context& ctx, const cgv::media::axis_aligned_box<T, 3>& box) {
                set_position(ctx, box.get_min_pnt());
                set_extent(ctx, box.get_max_pnt());
                set_position_is_center(false);
            }

            template <typename T>
            void set_box_array(const context& ctx, const std::vector<cgv::media::axis_aligned_box<T, 3> >& boxes) {
                set_composed_attribute_array(ctx, "position", &boxes.front(), boxes.size(), boxes[0].get_min_pnt());
                ref_composed_attribute_array(ctx, "extent", "position", &boxes.front(), boxes.size(), boxes[0].get_max_pnt());
                has_positions = true;
                has_extents = true;
                set_position_is_center(false);
            }

            template <typename T>
            void set_box_array(const context& ctx, const cgv::media::axis_aligned_box<T, 3>* boxes, size_t count) {
                set_composed_attribute_array(ctx, "position", boxes, count, boxes[0].get_min_pnt());
                ref_composed_attribute_array(ctx, "extent", "position", boxes, count, boxes[0].get_max_pnt());
                has_positions = true;
                has_extents = true;
                set_position_is_center(false);
            }

            template <typename T>
            void set_translation_array(const context& ctx, const std::vector<T>& translations) { has_translations = true; set_attribute_array(ctx, "translation", translations); }
            template <typename T>
            void set_translation_array(const context& ctx, const T* translations, size_t nr_elements, unsigned stride_in_bytes = 0) { has_translations = true; set_attribute_array(ctx, "translation", translations, nr_elements, stride_in_bytes); }
            void remove_translation_array(const context& ctx);
            template <typename T>
            void set_rotation_array(const context& ctx, const std::vector<T>& rotations) { has_rotations = true; set_attribute_array(ctx, "rotation", rotations); }
            template <typename T>
            void set_rotation_array(const context& ctx, const T* rotations, size_t nr_elements, unsigned stride_in_bytes = 0) { has_rotations = true; set_attribute_array(ctx, "rotation", rotations, nr_elements, stride_in_bytes); }
            void remove_rotation_array(const context& ctx);
            bool disable(context& ctx) override;
            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;
        };
        struct CGV_API box_render_style_reflect : public box_render_style
        {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
        extern CGV_API cgv::reflect::extern_reflection_traits<box_render_style, box_render_style_reflect> get_reflection_traits(const box_render_style&);
    }
}
 
#include <cgv/config/lib_end.h>