mesh_render_info.h

#pragma once
 
#include "render_info.h"
#include <cgv/media/mesh/simple_mesh.h>
 
#include "lib_begin.h"
 
namespace cgv {
    namespace render {
class CGV_API mesh_render_info : public render_info
{
public:
    typedef cgv::media::mesh::simple_mesh_base::attribute_type attribute_type;
    typedef cgv::math::fvec<idx_type, 3> idx3_type;
    typedef cgv::math::fvec<idx_type, 4> idx4_type;
    typedef std::map<attribute_type, uint32_t> attribute_map;
protected:
    std::vector<std::string> primitive_names;
    std::vector<idx3_type> material_primitive_start;
    bool include_tex_coords;
    bool include_normals;
    bool include_tangents;
    bool include_colors;
    size_t nr_vertices;
    size_t nr_edge_elements;
    size_t nr_triangle_elements;
    size_t element_size;
    draw_call wire_draw_call;
    cgv::render::type_descriptor position_descr;
    cgv::render::type_descriptor tex_coords_descr;
    size_t color_increment;
    cgv::media::ColorType ct;
    
    /*@name support for flexible interleaving and dynamic updates of vertex attributes */

    struct vbo_configuration
    {
        bool is_dynamic = false;
        cgv::media::mesh::simple_mesh_base::AttributeFlags attributes = cgv::media::mesh::simple_mesh_base::AttributeFlags(0);
        uint32_t stride = 0;
    };

    std::vector<vbo_configuration> vbo_config;
    struct attribute_configuration
    {
        uint32_t vbo_index = 0;
        uint32_t offset = 0;        
    };

    std::map<attribute_type, attribute_configuration> per_attribute_vbo_config;
    std::vector<idx4_type> unique_quadruples;
    bool attribute_is_used(attribute_type at) const;
    bool configure_vbos(cgv::render::context& ctx, const cgv::media::mesh::simple_mesh_base& mesh, 
        const attribute_map& attribute_to_vbo_index_map, const std::vector<int>& dynamic_vbo_idx);

    void construct_index_buffers(cgv::render::context& ctx, const cgv::media::mesh::simple_mesh_base& mesh,
                                 std::vector<idx4_type>& unique_quadruples, std::vector<idx_type>& per_corner_vertex_index,
                                 std::vector<idx_type>& edges_element_buffer, std::vector<idx_type>& triangles_element_buffer);
    void construct_element_vbo(cgv::render::context& ctx, const std::vector<idx_type>& edge_element_buffer, const std::vector<idx_type>& triangle_element_buffer);
    void construct_draw_calls(cgv::render::context& ctx);
public:
    mesh_render_info();
    bool is_constructed() const { return get_vbos().size() > 0; }
    bool is_bound() const { return get_aas().size() > 0; }
    template <typename T>
    void construct(cgv::render::context& ctx, cgv::media::mesh::simple_mesh<T>& mesh,
                   std::vector<idx_type>* tuple_pos_indices = nullptr,
                   std::vector<idx_type>* tuple_normal_indices = nullptr, 
                   int* num_floats_in_vertex = nullptr)
    {
        element_size = sizeof(T);
        position_descr = cgv::render::element_descriptor_traits<
            typename cgv::media::mesh::simple_mesh<T>::vec3_type>::get_type_descriptor(mesh.position(0));
        tex_coords_descr = cgv::render::element_descriptor_traits<typename cgv::media::mesh::simple_mesh<T>::vec2_type>::
            get_type_descriptor(typename cgv::media::mesh::simple_mesh<T>::vec2_type());
        attribute_map va_vbo_idx = { { attribute_type::position, 0 } };
        if (mesh.has_tex_coords())
            va_vbo_idx[attribute_type::texcoords] = 0;
        if (mesh.has_normals())
            va_vbo_idx[attribute_type::normal] = 0;
        if (mesh.has_tangents())
            va_vbo_idx[attribute_type::tangent] = 0;
        if (mesh.has_colors())
            va_vbo_idx[attribute_type::color] = 0;
        configure_vbos(ctx, mesh, va_vbo_idx, {});
        // construct render buffers
        std::vector<idx_type> vertex_indices, edge_element_buffer, triangle_element_buffer;
        std::vector<idx4_type> unique_quadruples;
        construct_index_buffers(ctx, mesh, unique_quadruples, vertex_indices, edge_element_buffer, triangle_element_buffer);
        // record which attributes each unique tuple was referencing
        for (const auto& tuple : unique_quadruples) {
            if (tuple_pos_indices)
                tuple_pos_indices->push_back(tuple[0]);
            if (tuple_normal_indices)
                tuple_normal_indices->push_back(tuple[2]);
        }
        std::vector<uint8_t> attrib_buffer;
        mesh.extract_vertex_attribute_buffer_base(unique_quadruples, vbo_config.front().attributes, attrib_buffer);
        ref_vbos().push_back(new cgv::render::vertex_buffer(cgv::render::VBT_VERTICES));
        ref_vbos().back()->create(ctx, attrib_buffer);
        construct_element_vbo(ctx, edge_element_buffer, triangle_element_buffer);
        construct_draw_calls(ctx);
    }

    template <typename T>
    void construct_dynamic(cgv::render::context& ctx, cgv::media::mesh::simple_mesh<T>& mesh,
        const attribute_map& va_vbo_idx, const std::vector<int>& dynamic_vbo_idx)
    {
        element_size = sizeof(T);
        position_descr = cgv::render::element_descriptor_traits<
            typename cgv::media::mesh::simple_mesh<T>::vec3_type>::get_type_descriptor(mesh.position(0));
        tex_coords_descr = cgv::render::element_descriptor_traits<typename cgv::media::mesh::simple_mesh<T>::vec2_type>::
            get_type_descriptor(typename cgv::media::mesh::simple_mesh<T>::vec2_type());
        configure_vbos(ctx, mesh, va_vbo_idx, dynamic_vbo_idx);
        bool keep_unique_quadrupels = !dynamic_vbo_idx.empty();
        // construct unique attribute index tupels that form vertices in the render data together with
        // vector of per corner vertex indices, vertex index pairs forming edges and vertex index triples forming triangles
        std::vector<idx4_type> tmp_unique_quadruples;
        std::vector<idx4_type>& unique_quadruples_ref = keep_unique_quadrupels ? unique_quadruples : tmp_unique_quadruples;
        std::vector<idx_type> per_corner_vertex_index, edge_element_buffer, triangle_element_buffer;
        construct_index_buffers(ctx, mesh, unique_quadruples_ref, per_corner_vertex_index, edge_element_buffer, triangle_element_buffer);
        //
        for (const auto& vc : vbo_config) {
            std::vector<uint8_t> attrib_buffer;
            auto vca = vc.attributes;
            mesh.extract_vertex_attribute_buffer_base(unique_quadruples_ref, vca, attrib_buffer);
            ref_vbos().push_back(new cgv::render::vertex_buffer(cgv::render::VBT_VERTICES));
            ref_vbos().back()->create(ctx, attrib_buffer);
        }
        construct_element_vbo(ctx, edge_element_buffer, triangle_element_buffer);
        construct_draw_calls(ctx);
    }

    template <typename T>
    void update_vbo(cgv::render::context& ctx, cgv::media::mesh::simple_mesh<T>& mesh, int vbo_index)
    {
        const auto& vc = vbo_config[vbo_index];
        std::vector<uint8_t> attrib_buffer;
        auto vca = vc.attributes;
        mesh.extract_vertex_attribute_buffer_base(unique_quadruples, vca, attrib_buffer);
        ref_vbos()[vbo_index]->replace(ctx, 0, &attrib_buffer[0], attrib_buffer.size());
    }

    void set_nr_instances(unsigned nr);
    size_t get_nr_primitives() const { return primitive_names.size(); }
    const std::string& get_primitive_name(size_t i) const { return primitive_names[i]; }
    size_t get_nr_fragments() const { return material_primitive_start.size(); }
    size_t get_material_index(size_t i) const { return material_primitive_start[i](0); }
    size_t get_primitive_index(size_t i) const { return material_primitive_start[i](1); }

    size_t get_nr_vertices() const { return nr_vertices; };
    size_t get_nr_edge_elements() const { return nr_edge_elements; };
    size_t get_nr_triangle_elements() const { return nr_triangle_elements; };
    size_t get_element_size() const { return element_size; };

    void draw_primitive(cgv::render::context& ctx, size_t primitive_index, bool skip_opaque = false, bool skip_blended = false, bool use_materials = true);
    bool bind(context& ctx, shader_program& prog, bool force_success, int aa_index = -1);
    bool bind_wireframe(context& ctx, shader_program& prog, bool force_success);
    void draw_wireframe(cgv::render::context& ctx);
    void destruct(cgv::render::context& ctx);
};
    }
}
 
#include <cgv/config/lib_end.h>