cone_renderer.h

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


        extern CGV_API cone_renderer& ref_cone_renderer(context& ctx, int ref_count_change = 0);
 
        struct CGV_API cone_render_style : public surface_render_style {
            float radius_scale = 1.0f;
            float radius = 1.0f;
 
            bool show_caps = true;
            bool rounded_caps = false;
 
            bool enable_texturing = false;
            enum TextureBlendMode {
                TBM_MIX = 0,
                TBM_TINT = 1,
                TBM_MULTIPLY = 2,
                TBM_INVERSE_MULTIPLY = 3,
                TBM_ADD = 4,
            } texture_blend_mode = TextureBlendMode::TBM_MIX;
            float texture_blend_factor = 1.0f;
            bool texture_tile_from_center = false;
            vec2 texture_offset = { 0.0f };
            vec2 texture_tiling = { 1.0f };
            bool texture_use_reference_length = false;
            float texture_reference_length = 1.0f;
 
            bool enable_ambient_occlusion = false;
            float ao_offset = 0.04f;
            float ao_distance = 0.8f;
            float ao_strength = 1.0f;
 
            vec3 tex_offset = { 0.0f };
            vec3 tex_scaling = { 1.0f };
            vec3 tex_coord_scaling = { 1.0f };
            float texel_size = 1.0f;
            float cone_angle_factor = 1.0f;
            std::vector<vec3> sample_dirs = std::vector<vec3>(3, { 0.0f, 1.0f, 0.0f });
        };

        class CGV_API cone_renderer : public surface_renderer {
        protected:
            bool has_radii = false;
            std::string get_default_prog_name() const override { return "cone.glpr"; }
            render_style* create_render_style() const override { return new cone_render_style(); }
            void update_shader_program_options(shader_compile_options& options) const override;
 
            texture* albedo_texture = nullptr;
            texture* density_texture = nullptr;
 
        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;
            bool set_albedo_texture(texture* tex);
            bool set_density_texture(texture* tex);
            bool enable(context& ctx) override;
            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 = float>
            void set_sphere_array(const context& ctx, const std::vector<cgv::math::fvec<T, 4> >& spheres) {
                set_composed_attribute_array(ctx, "position", &spheres.front(), spheres.size(), reinterpret_cast<const cgv::math::fvec<T, 3>&>(spheres.front()));
                ref_composed_attribute_array(ctx, "radius", "position", &spheres.front(), spheres.size(), spheres[0][3]);
                has_positions = true;
                has_radii = true;
            }

            template <typename T = float>
            void set_sphere_array(const context& ctx, const cgv::math::fvec<T, 4>* spheres, size_t nr_elements) {
                set_composed_attribute_array(ctx, "position", spheres, nr_elements, reinterpret_cast<const cgv::math::fvec<T, 3>&>(*spheres));
                ref_composed_attribute_array(ctx, "radius", "position", spheres, nr_elements, (*spheres)[3]);
                has_positions = true;
                has_radii = true;
            }

            bool validate_attributes(const context& ctx) const override;
 
            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;
            void clear(const context& ctx) override;
        };
 
        struct CGV_API cone_render_style_reflect : public cone_render_style {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
 
        extern CGV_API cgv::reflect::extern_reflection_traits<cone_render_style, cone_render_style_reflect> get_reflection_traits(const cone_render_style&);
    }
}
 
#include <cgv/config/lib_end.h>