rectangle_renderer.h

#pragma once
 
#include "surface_renderer.h"
#include <cgv/reflect/reflect_enum.h>
#include <cgv/render/textured_rectangle.h>
 
#include "gl/lib_begin.h"
 
namespace cgv {
    namespace render {
        class CGV_API rectangle_renderer;
 
 
        extern CGV_API rectangle_renderer& ref_rectangle_renderer(context& ctx, int ref_count_change = 0);
 
        enum RectangleTextureMode
        {
            RTM_REPLACE = 0,                       // result   = texture
            RTM_REPLACE_ALPHA,                     // result   = vec4(color.rgb, texture.r)
            RTM_MULTIPLY_COLOR,                    // result   = color * texture
            RTM_MULTIPLY_SECONDARY_COLOR,          // result   = secondary_color * texture
            RTM_MULTIPLY_BORDER_COLOR,             // result   = border_color * texture
            RTM_MIX_COLOR_AND_SECONDARY_COLOR,     // result   = mix(color,secondary_color,texture)
            RTM_MIX_COLOR_AND_BORDER_COLOR,        // result   = mix(color,border_color,texture)
            RTM_MIX_SECONDARY_COLOR_AND_COLOR,     // result   = mix(secondary_color,color,texture)
            RTM_MIX_BORDER_COLOR_AND_COLOR,        // result   = mix(border_color,color,texture)
            RTM_RED_MIX_COLOR_AND_SECONDARY_COLOR, // result   = mix(color,secondary_color,texture.r)
            RTM_RED_MIX_COLOR_AND_BORDER_COLOR,    // result   = mix(color,border_color,texture.r)
            RTM_RED_MIX_SECONDARY_COLOR_AND_COLOR, // result   = mix(secondary_color,color,texture.r)
            RTM_RED_MIX_BORDER_COLOR_AND_COLOR     // result   = mix(border_color,color,texture.r)
        };
        enum RectangleBoderMode
        {
            RBM_SEPARATE = 0, // border_width.xy = percentual_border_width*extent.xy
            RBM_WIDTH,        // border_width.xy = vec2(percentual_border_width*extent.x)
            RBM_HEIGHT,       // border_width.xy = vec2(percentual_border_width*extent.y)
            RBM_MIN           // border_width.xy = vec2(percentual_border_width*min(extent.x, extent.y))
        };
        extern CGV_API cgv::reflect::enum_reflection_traits<RectangleTextureMode> get_reflection_traits(const RectangleTextureMode&);
        extern CGV_API cgv::reflect::enum_reflection_traits<RectangleBoderMode> get_reflection_traits(const RectangleBoderMode&);
        struct CGV_API rectangle_render_style : public surface_render_style
        {
 
            mutable bool position_is_center;
            rgba default_secondary_color;
            rgba default_border_color;
            float border_width_in_pixel;
            float percentual_border_width;
            RectangleBoderMode border_mode;
            float pixel_blend;
            RectangleTextureMode texture_mode;
 
            float default_depth_offset;
            bool blend_rectangles;
            rectangle_render_style();
        };
 
        class CGV_API rectangle_renderer : public surface_renderer
        {
        protected:
            bool has_extents;
            bool has_secondary_colors;
            bool has_border_colors;
            bool has_border_infos;
            bool has_translations;
            bool has_rotations;
            bool has_depth_offsets;
            float y_view_angle;
            render_style* create_render_style() const;
            bool build_shader_program(context& ctx, shader_program& prog, const shader_define_map& defines);
        public:
            rectangle_renderer();
            void set_y_view_angle(float y_view_angle);
            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_position_is_center(bool _position_is_center);
            template <typename T>
            void set_extent(const context& ctx, const cgv::math::fvec<T, 2U>& 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<cgv::math::fvec<T, 2U>>& extents) { has_extents = true;  set_attribute_array(ctx, "extent", extents); }
            template <typename T>
            void set_extent_array(const context& ctx, const cgv::math::fvec<T, 2U>* 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>
            void set_rectangle(const context& ctx, const cgv::media::axis_aligned_box<T, 2>& box) {
                has_positions = true;
                has_extents = true;
                set_position_is_center(false);
                ref_prog().set_attribute(ctx, "position", box.get_min_pnt());
                ref_prog().set_attribute(ctx, "extent", box.get_max_pnt());
            }
            template <typename T>
            void set_rectangle_array(const context& ctx, const std::vector<cgv::media::axis_aligned_box<T, 2> >& 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_rectangle_array(const context& ctx, const cgv::media::axis_aligned_box<T, 2>* 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);
            }
            void set_textured_rectangle(const context& ctx, const textured_rectangle& tcr);
            void set_textured_rectangle_array(const context& ctx, const std::vector<textured_rectangle>& tc_rects) {
                set_composed_attribute_array(ctx, "position", &tc_rects.front(), tc_rects.size(), tc_rects[0].rectangle.get_min_pnt());
                ref_composed_attribute_array(ctx, "extent", "position", &tc_rects.front(), tc_rects.size(), tc_rects[0].rectangle.get_max_pnt());
                ref_composed_attribute_array(ctx, "texcoord", "position", &tc_rects.front(), tc_rects.size(), tc_rects[0].texcoords);
                has_positions = true;
                has_extents = true;
                has_texcoords = true;
                set_position_is_center(false);
            }
            void set_textured_rectangle_array(const context& ctx, const textured_rectangle* tc_rects, size_t count) {
                set_composed_attribute_array(ctx, "position", tc_rects, count, tc_rects[0].rectangle.get_min_pnt());
                ref_composed_attribute_array(ctx, "extent", "position", tc_rects, count, tc_rects[0].rectangle.get_max_pnt());
                ref_composed_attribute_array(ctx, "texcoord", "position", tc_rects, count, tc_rects[0].texcoords);
                has_positions = true;
                has_extents = true;
                has_texcoords = true;
                set_position_is_center(false);
            }
            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_border_color(const context& ctx, const T& color) { has_border_colors = true; ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "border_color"), color); }
            template <typename T>
            void set_border_color_array(const context& ctx, const std::vector<T>& colors) { has_border_colors = true;  set_attribute_array(ctx, "border_color", colors); }
            template <typename T>
            void set_border_color_array(const context& ctx, const T* colors, size_t nr_elements, unsigned stride_in_bytes = 0) { has_border_colors = true;  set_attribute_array(ctx, "border_color", colors, nr_elements, stride_in_bytes); }
            void set_border_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_border_color_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_border_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_border_color_array(const context& ctx);
            template <typename T>
            void set_border_info(const context& ctx, const cgv::math::fvec<T, 3>& border_info) { has_border_infos = true;  ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "border_info"), border_info); }
            template <typename T>
            void set_border_info_array(const context& ctx, const std::vector<T>& border_infos) { has_border_infos = true;  set_attribute_array(ctx, "border_info", border_infos); }
            template <typename T>
            void set_border_info_array(const context& ctx, const T* border_infos, size_t nr_elements, unsigned stride_in_bytes = 0) { has_border_infos = true;  set_attribute_array(ctx, "border_info", border_infos, nr_elements, stride_in_bytes); }
            void set_border_info_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_border_info_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_border_info_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_border_info_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 = float>
            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); }
            void remove_depth_offset_array(const context& ctx);
            template <typename T>
            void set_translation(const context& ctx, const T& translation) { has_translations = true; ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "translation"), translation); }
            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) { has_translations = true; set_attribute_array(ctx, "translation", translations, nr_elements, stride); }
            void remove_translation_array(const context& ctx);
            template <typename T>
            void set_rotation(const context& ctx, const T& rotation) { has_rotations = true; ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "rotation"), rotation); }
            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 = 0) { has_rotations = true; set_attribute_array(ctx, "rotation", rotations, nr_elements, stride); }
            void remove_rotation_array(const 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 rectangle_render_style_reflect : public rectangle_render_style
        {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
        extern CGV_API cgv::reflect::extern_reflection_traits<rectangle_render_style, rectangle_render_style_reflect> get_reflection_traits(const rectangle_render_style&);
    }
}
 
#include <cgv/config/lib_end.h>