surface_renderer.h

#pragma once
 
#include "group_renderer.h"
#include <cgv_reflect_types/media/illum/textured_surface_material.h>
#include <cgv/media/illum/textured_surface_material.h>
 
#include "gl/lib_begin.h"
 
namespace cgv { // @<
    namespace render { // @<
 
        enum ColorMapping {
            CM_NONE = 0,
            CM_COLOR_FRONT = 1,
            CM_COLOR_BACK = 2,
            CM_COLOR = CM_COLOR_FRONT | CM_COLOR_BACK,
            CM_OPACITY_FRONT = 4,
            CM_OPACITY_BACK = 8,
            CM_OPACITY = CM_OPACITY_FRONT | CM_OPACITY_BACK,
            CM_COLOR_AND_OPACITY = CM_COLOR | CM_OPACITY
        };
 
        class CGV_API surface_renderer;
 
 
        extern CGV_API surface_renderer& ref_surface_renderer(context& ctx, int ref_count_change = 0);
 
        struct CGV_API surface_render_style : public group_render_style
        {
            cgv::media::illum::surface_material::color_type surface_color = cgv::media::illum::surface_material::color_type(0.4f, 0.1f, 0.7f);
            float surface_opacity = 1.0f;
            CullingMode culling_mode = CM_OFF;
            IlluminationMode illumination_mode = IM_ONE_SIDED;
            ColorMapping map_color_to_material = CM_COLOR;
            cgv::media::illum::textured_surface_material material;
            int max_nr_lights = 2;
        };
 
        class CGV_API surface_renderer : public group_renderer
        {
        protected:
            bool has_normals = false;
            bool has_texcoords = false;
            bool cull_per_primitive = true;
            std::string get_default_prog_name() const override { return "textured_surface.glpr"; }
            render_style* create_render_style() const override { return new surface_render_style(); }
            void update_shader_program_options(shader_compile_options& options) const override;
            bool build_shader_program(context& ctx, shader_program& prog, const 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;
            bool enable(context& ctx) override;
            bool disable(context& ctx) override;
            template <typename T>
            void set_normal(const context& ctx, const cgv::math::fvec<T, 3>& normal) { has_normals = true;  ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "normal"), normal); }
            template <typename T>
            void set_normal_array(const context& ctx, const std::vector<T>& normals) { has_normals = true;  set_attribute_array(ctx,  "normal", normals); }
            template <typename T>
            void set_normal_array(const context& ctx, const T* normals, size_t nr_elements, unsigned stride_in_bytes = 0) { has_normals = true;  set_attribute_array(ctx, "normal", normals, nr_elements, stride_in_bytes); }
            void set_normal_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_normal_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_normal_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_normal_array(const context& ctx);
            template <typename T>
            void set_texcoord(const context& ctx, const T& texcoord) { has_texcoords = true;  ref_prog().set_attribute(ctx, get_prog_attribute_location(ctx, "texcoord"), texcoord); }
            template <typename T>
            void set_texcoord_array(const context& ctx, const std::vector<T>& texcoords) { has_texcoords = true;  set_attribute_array(ctx, "texcoord", texcoords); }
            template <typename T>
            void set_texcoord_array(const context& ctx, const T* texcoords, size_t nr_elements, unsigned stride_in_bytes = 0) { has_texcoords = true;  set_attribute_array(ctx, "texcoord", texcoords, nr_elements, stride_in_bytes); }
            void set_texcoord_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_texcoord_array(const context& ctx, const vertex_buffer& vbo, size_t offset_in_bytes, size_t nr_elements, unsigned stride_in_bytes = 0) { set_texcoord_array(ctx, type_descriptor(element_descriptor_traits<T>::get_type_descriptor(T()), true), vbo, offset_in_bytes, nr_elements, stride_in_bytes); }
            void remove_texcoord_array(const context& ctx);
        };
        struct CGV_API surface_render_style_reflect : public surface_render_style
        {
            bool self_reflect(cgv::reflect::reflection_handler& rh);
        };
        extern CGV_API cgv::reflect::extern_reflection_traits<surface_render_style, surface_render_style_reflect> get_reflection_traits(const surface_render_style&);
    }
}
 
#include <cgv/config/lib_end.h>