ellipsoid_renderer.h

#pragma once
 
#include "surface_renderer.h"
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<
        class CGV_API ellipsoid_renderer;
 
 
        extern CGV_API ellipsoid_renderer& ref_ellipsoid_renderer(context& ctx, int ref_count_change = 0);
 
        struct CGV_API ellipsoid_render_style : public surface_render_style
        {
            /*@name ellipsoid rendering attributes*/
 
            float size_scale;
            cgv::vec3 size;
 
            ellipsoid_render_style();
        };
 
        class CGV_API ellipsoid_renderer : public surface_renderer
        {
        protected:
            bool has_sizes;
            bool has_orientations;
            render_style* create_render_style() const;
            bool build_shader_program(context& ctx, shader_program& prog, const shader_define_map& defines);
        public:
            ellipsoid_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);
            template <typename T = float>
            void set_size(const context& ctx, const T& size) {
                has_sizes = true;
                ref_prog().set_attribute(ctx, ref_prog().get_attribute_location(ctx, "size"), size);
            }
            template <typename T = float>
            void set_size_array(const context& ctx, const std::vector<T>& sizes) {
                has_sizes = true;
                set_attribute_array(ctx, "size", sizes);
            }
            template <typename T>
            void set_size_array(const context& ctx, const T* sizes, size_t nr_elements, unsigned stride_in_bytes = 0) {
                has_sizes = true;
                set_attribute_array(ctx, "size", sizes, nr_elements, stride_in_bytes);
            }
            void remove_size_array(const context& ctx);
            template <typename T = float>
            void set_orientation(const context& ctx, const cgv::math::quaternion<T>& orientation) {
                has_orientations = true;
                ref_prog().set_attribute(ctx, ref_prog().get_attribute_location(ctx, "orientation"), orientation);
            }
            template <typename T = float>
            void set_orientation_array(const context& ctx, const std::vector<cgv::math::quaternion<T>>& orientations) {
                has_orientations = true;
                set_attribute_array(ctx, "orientation", orientations);
            }
            template <typename T>
            void set_orientation_array(const context& ctx, const T* orientations, size_t nr_elements, unsigned stride_in_bytes = 0) {
                has_orientations = true;
                set_attribute_array(ctx, "orientation", orientations, nr_elements, stride_in_bytes);
            }
            void remove_orientation_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 ellipsoid_render_style_reflect : public ellipsoid_render_style
        {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
        extern CGV_API cgv::reflect::extern_reflection_traits<ellipsoid_render_style, ellipsoid_render_style_reflect> get_reflection_traits(const ellipsoid_render_style&);
    }
}
 
 
#include <cgv/config/lib_end.h>