slab_renderer.h

#pragma once
 
#include "group_renderer.h"
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<
        class CGV_API slab_renderer;
 
 
        extern CGV_API slab_renderer& ref_slab_renderer(context& ctx, int ref_count_change = 0);
 
        struct CGV_API slab_render_style : public group_render_style
        {
            float thickness_scale;
            int tex_unit;
            int tf_tex_unit;
            bool use_transfer_function;
            int tf_source_channel;
            int tex_idx_offset;
            int tex_idx_stride;
            float step_size;
            float opacity;
            float falloff_mix;
            float falloff_strength;
            float scale;
            slab_render_style();
        };
 
        class CGV_API slab_renderer : public group_renderer
        {
        protected:
            bool has_extents;
            bool has_translations;
            bool has_rotations;
            bool has_texture_indices;
            bool position_is_center;
            render_style* create_render_style() const;
            bool build_shader_program(context& ctx, shader_program& prog, const shader_define_map& defines);
        public:
            slab_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);
            void set_position_is_center(bool _position_is_center);
            bool enable(context& ctx);
            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); }
            template <typename T>
            void set_box_array(const context& ctx, const std::vector<cgv::media::axis_aligned_box<T, 3> >& box) {
                set_composed_attribute_array(ctx, "position", &box.front(), box.size(), box[0].get_min_pnt());
                ref_composed_attribute_array(ctx, "extent", "position", &box.front(), box.size(), box[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>* box, size_t count) {
                set_composed_attribute_array(ctx, "position", box, count, box[0].get_min_pnt());
                ref_composed_attribute_array(ctx, "extent", "position", box, count, box[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) { has_translations = true; set_attribute_array(ctx, "translation", translations, nr_elements, stride); }
            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) { has_rotations = true; set_attribute_array(ctx, "rotation", rotations, nr_elements, stride); }
            template <typename T>
            void set_texture_index_array(const context& ctx, const std::vector<T>& texture_indices) { has_texture_indices = true; set_attribute_array(ctx, "texture_index", texture_indices); }
            template <typename T>
            void set_texture_index_array(const context& ctx, const T* texture_indices, size_t nr_elements, unsigned stride_in_bytes = 0) { has_texture_indices = true;  set_attribute_array(ctx, "texture_index", texture_indices, nr_elements, stride_in_bytes); }
            bool validate_attributes(const context& ctx) const;
            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 slab_render_style_reflect : public slab_render_style
        {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
        extern CGV_API cgv::reflect::extern_reflection_traits<slab_render_style, slab_render_style_reflect> get_reflection_traits(const slab_render_style&);
    }
}
 
#include <cgv/config/lib_end.h>