simple_mesh.h

#pragma once
 
#include <cstdint>
#include <vector>
 
#include <cgv/math/fvec.h>
#include <cgv/math/fmat.h>
#include <cgv/utils/file.h>
#include <cgv/media/illum/textured_surface_material.h>
#include <cgv/media/axis_aligned_box.h>
#include <cgv/media/colored_model.h>
 
#include "../lib_begin.h"
 
namespace cgv {
    namespace media {
        namespace mesh {
            
template <typename T>
class simple_mesh_obj_reader;
 
template <typename T>
class CGV_API obj_loader_generic;
 
class CGV_API simple_mesh_base : public colored_model
{
public:
    typedef cgv::type::uint32_type idx_type;
    typedef cgv::math::fvec<idx_type,2> idx2_type;
    typedef cgv::math::fvec<idx_type,3> idx3_type;
    typedef cgv::math::fvec<idx_type,4> idx4_type;
    typedef illum::textured_surface_material mat_type;
    enum class attribute_type {
        begin=0, position=0, texcoords=1, normal=2, tangent=3, color=4, end=5
    };
    // flags to define a selection of attributes
    enum AttributeFlags {
        AF_position = 1, 
        AF_texcoords = 2, 
        AF_normal = 4, 
        AF_tangent = 8, 
        AF_color = 16  
    };
    static std::string get_attribute_name(attribute_type attr);
    static AttributeFlags get_attribute_flag(attribute_type attr);
    virtual          bool  has_attribute(attribute_type attr) const = 0;
    virtual const uint8_t* get_attribute_ptr(attribute_type attr, idx_type ai = 0) const = 0;
    virtual        size_t  get_attribute_size(attribute_type attr) const = 0;
    virtual        size_t  get_attribute_offset(attribute_type attr) const = 0;
protected:
    std::vector<idx_type> position_indices;
    std::vector<idx_type> tex_coord_indices;
    std::vector<idx_type> normal_indices;
    std::vector<idx_type> tangent_indices;
    std::vector<idx_type> faces;
    std::vector<idx_type> group_indices;
    std::vector<std::string> group_names;
    std::vector<idx_type> material_indices;
    std::vector<mat_type> materials;
public:
    simple_mesh_base();
    simple_mesh_base(const simple_mesh_base& smb);
    simple_mesh_base(simple_mesh_base&& smb);
    simple_mesh_base& operator=(const simple_mesh_base& smb);
    simple_mesh_base& operator=(simple_mesh_base&& smb);
    virtual idx_type get_nr_positions() const = 0;
    virtual uint32_t get_coord_size() const = 0;
    idx_type start_face();
    idx_type new_corner(idx_type position_index, idx_type normal_index = -1, idx_type tex_coord_index = -1); //FIXME: -1 underflows unsigned int!
    idx_type c2p(idx_type ci) const { return position_indices[ci]; }
    idx_type c2n(idx_type ci) const { return normal_indices[ci]; }
    bool has_normal_indices() const { return normal_indices.size() > 0 && normal_indices.size() == position_indices.size(); }
    idx_type c2t(idx_type ci) const { return tex_coord_indices[ci]; }
    bool has_tex_coord_indices() const { return tex_coord_indices.size() > 0 && tex_coord_indices.size() == position_indices.size(); }
    idx_type get_nr_faces() const { return idx_type(faces.size()); }
    idx_type get_nr_corners() const { return idx_type(position_indices.size()); }
    idx_type begin_corner(idx_type fi) const { return faces[fi]; }
    idx_type end_corner(idx_type fi) const { return fi + 1 == faces.size() ? idx_type(position_indices.size()) : faces[fi + 1]; }
    idx_type face_degree(idx_type fi) const { return end_corner(fi) - begin_corner(fi); }
    size_t get_nr_materials() const { return materials.size(); }
    idx_type new_material() { materials.push_back(mat_type()); return idx_type(materials.size() - 1); }
    const mat_type& get_material(size_t i) const { return materials[i]; }
    mat_type& ref_material(size_t i) { return materials[i]; }
    const idx_type& material_index(idx_type fi) const { return material_indices[fi]; }
    idx_type& material_index(idx_type fi) { return material_indices[fi]; }
    size_t get_nr_groups() const { return group_names.size(); }
    const std::string& group_name(size_t i) const { return group_names[i]; }
    std::string& group_name(size_t i) { return group_names[i]; }
    idx_type new_group(const std::string& name) { group_names.push_back(name); return idx_type(group_names.size() - 1); }
    const idx_type& group_index(idx_type fi) const { return group_indices[fi]; }
    idx_type& group_index(idx_type fi) { return group_indices[fi]; }
    void revert_face_orientation();
    void sort_faces(std::vector<idx_type>& perm, bool by_group = true, bool by_material = true) const;
    void merge_indices(std::vector<idx_type>& vertex_indices, std::vector<idx4_type>& unique_tuples,
                       bool* include_tex_coords_ptr = 0, bool* include_normals_ptr = 0, bool* include_tangents_ptr = 0) const;
    void extract_triangle_element_buffer(const std::vector<idx_type>& vertex_indices,
                                         std::vector<idx_type>& triangle_element_buffer,
                                         const std::vector<idx_type>* face_permutation_ptr = 0,
                                         std::vector<idx3_type>* material_group_start_ptr = 0) const;
    void extract_wireframe_element_buffer(const std::vector<idx_type>& vertex_indices,
                                          std::vector<idx_type>& edge_element_buffer) const;
    idx_type extract_vertex_attribute_buffer_base(const std::vector<idx4_type>& unique_quadruples, AttributeFlags& flags, std::vector<uint8_t>& attrib_buffer) const;
    void extract_triangle_indices(std::vector<idx3_type>& position_indices, std::vector<idx3_type>* tex_coord_indices = nullptr, std::vector<idx3_type>* normal_indices = nullptr, std::vector<idx3_type>* tangent_indices = nullptr) const;
 
    idx_type compute_inv(
        std::vector<idx_type>& inv,
        bool link_non_manifold_edges = false,
        std::vector<idx_type>* p2c_ptr = 0, 
        std::vector<idx_type>* next_ptr = 0, 
        std::vector<idx_type>* prev_ptr = 0,
        std::vector<idx_type>* unmatched = 0,
        std::vector<idx_type>* non_manifold = 0,
        std::vector<idx_type>* unmatched_elements = 0,
        std::vector<idx_type>* non_manifold_elements = 0) const;
    idx_type compute_c2e(const std::vector<idx_type>& inv, std::vector<idx_type>& c2e, std::vector<idx_type>* e2c_ptr = 0) const;
    void compute_c2f(std::vector<idx_type>& c2f) const;
};
 
template <typename T = float>
class CGV_API simple_mesh : public simple_mesh_base
{
public:
    using numeric_type = T;
    
    typedef simple_mesh<T> mesh_type;
    typedef typename cgv::media::axis_aligned_box<T, 3> box_type;
    typedef typename cgv::math::fvec<T, 2> vec2_type;
    typedef typename cgv::math::fvec<T, 3> vec3_type;
    typedef typename cgv::math::fmat<T, 3, 3> mat3_type;
protected:
    friend class simple_mesh_obj_reader<T>;
    std::vector<vec3_type>  positions;
    std::vector<vec3_type>  normals;
    std::vector<vec3_type>  tangents;
    std::vector<vec2_type>  tex_coords;
    bool has_attribute(attribute_type attr) const {
        switch (attr) {
        case attribute_type::position:  return true;
        case attribute_type::texcoords: return has_tex_coords() && has_tex_coord_indices();
        case attribute_type::normal:    return has_normals() && has_normal_indices();
        case attribute_type::tangent:   return has_tangents();
        case attribute_type::color:     return has_colors();
        default: /* see below */;
        }
        return false;
    }
    const uint8_t* get_attribute_ptr(attribute_type attr, idx_type ai = 0) const {
        switch (attr) {
        case attribute_type::position:  return reinterpret_cast<const uint8_t*>( &positions[ai]);
        case attribute_type::texcoords: return reinterpret_cast<const uint8_t*>(&tex_coords[ai]);
        case attribute_type::normal:    return reinterpret_cast<const uint8_t*>(   &normals[ai]);
        case attribute_type::tangent:   return reinterpret_cast<const uint8_t*>(  &tangents[ai]);
        case attribute_type::color:     return reinterpret_cast<const uint8_t*>(get_color_data_ptr()) + ai * get_color_size();
        default: /* see below */;
        }
        return nullptr;
    }
    size_t get_attribute_size(attribute_type attr) const {
        switch (attr) {
        case attribute_type::position:  return sizeof(vec3_type);
        case attribute_type::texcoords: return sizeof(vec2_type);
        case attribute_type::normal:    return sizeof(vec3_type);
        case attribute_type::tangent:   return sizeof(vec3_type);
        case attribute_type::color:     return get_color_size();
        default: /* see below */;
        }
        return 0;
    }
    size_t get_attribute_offset(attribute_type attr) const
    {
        size_t s = get_attribute_size(attr);
        if (s < sizeof(T))
            s = sizeof(T);
        return s;
    }
    vec3_type compute_normal(const vec3_type& p0, const vec3_type& p1, const vec3_type& p2);
public:
    simple_mesh(const simple_mesh<T>& sm);
    simple_mesh(simple_mesh<T>&& sm);
    simple_mesh(const std::string& conway_notation = "");
    simple_mesh<T>& operator= (const simple_mesh<T>& sm);
    simple_mesh<T>& operator= (simple_mesh<T>&& sm);
    uint32_t get_coord_size() const { return sizeof(T); }
    void clear();
 
    idx_type new_position(const vec3_type& p) { positions.push_back(p); return idx_type(positions.size()-1); }
    idx_type get_nr_positions() const { return idx_type(positions.size()); }
    vec3_type& position(idx_type pi) { return positions[pi]; }
    const vec3_type& position(idx_type pi) const { return positions[pi]; }
    const std::vector<vec3_type>& get_positions() const { return positions; }
    std::vector<vec3_type>& ref_positions() { return positions; }
 
    idx_type new_normal(const vec3_type& n) { normals.push_back(n); return idx_type(normals.size()-1); }
    bool has_normals() const { return get_nr_normals() > 0; }
    idx_type get_nr_normals() const { return idx_type(normals.size()); }
    vec3_type& normal(idx_type ni) { return normals[ni]; }
    const vec3_type& normal(idx_type ni) const { return normals[ni]; }
    const std::vector<vec3_type>& get_normals() const { return normals; }
 
    idx_type new_tangent(const vec3_type& tc) { tangents.push_back(tc); return idx_type(tangents.size() - 1); }
    bool has_tangents() const { return get_nr_tangents() > 0; }
    idx_type get_nr_tangents() const { return idx_type(tangents.size()); }
    vec3_type& tangent(idx_type ti) { return tangents[ti]; }
    const vec3_type& tangent(idx_type ti) const { return tangents[ti]; }
 
    idx_type new_tex_coord(const vec2_type& tc) { tex_coords.push_back(tc); return idx_type(tex_coords.size() - 1); }
    bool has_tex_coords() const { return get_nr_tex_coords() > 0; }
    idx_type get_nr_tex_coords() const { return idx_type(tex_coords.size()); }
    vec2_type& tex_coord(idx_type ti) { return tex_coords[ti]; }
    const vec2_type& tex_coord(idx_type ti) const { return tex_coords[ti]; }
 
    bool compute_face_normal(idx_type fi, vec3_type& nml, bool normalize = true) const;
    vec3_type compute_face_center(idx_type fi) const;
    void compute_face_normals(bool construct_normal_indices = true);
    void compute_face_tangents(bool construct_tangent_indices = true);
    void ambo();
    void truncate(T lambda = 0.33333f);
    void snub(T lambda = 0.33333f);
    void dual();
    void gyro(T lambda = 0.3333f);
    void join();
    void ortho();
    void construct_conway_polyhedron(const std::string& conway_notation);
 
    box_type compute_box() const;
    void compute_vertex_normals(bool use_parallel_implementation = true);
    void construct(const obj_loader_generic<T>& loader, bool copy_grp_info, bool copy_material_info);
    bool read(const std::string& file_name);
    bool write(const std::string& file_name) const;
    unsigned extract_vertex_attribute_buffer(const std::vector<idx4_type>& unique_quadruples, bool include_tex_coords,
                                             bool include_normals, bool include_tangents, std::vector<T>& attrib_buffer,
                                             bool* include_colors_ptr = 0, int* num_floats_in_vertex = nullptr) const;
    void transform(const mat3_type& linear_transformation, const vec3_type& translation);
    void transform(const mat3_type& linear_transform, const vec3_type& translation, const mat3_type& inverse_linear_transform);
};
 
        }
    }
}
 
#include <cgv/config/lib_end.h>