simple_mesh.h

#pragma once
 
#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;
 
class CGV_API simple_mesh_base : public colored_model
{
public:
        typedef cgv::type::uint32_type idx_type;
        typedef cgv::math::fvec<idx_type, 2> vec2i;
        typedef cgv::math::fvec<idx_type, 3> vec3i;
        typedef illum::textured_surface_material mat_type;
protected:
        std::vector<idx_type> position_indices;
        std::vector<idx_type> normal_indices;
        std::vector<idx_type> tex_coord_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& operator=(const simple_mesh_base& smb);
        virtual idx_type get_nr_positions() 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);
        idx_type c2p(idx_type ci) const { return position_indices[ci]; }
        idx_type c2n(idx_type ci) const { return normal_indices[ci]; }
        idx_type c2t(idx_type ci) const { return tex_coord_indices[ci]; }
        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<vec3i>& unique_triples, bool* include_tex_coords_ptr = 0, bool* include_normals_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_perm_ptr = 0, std::vector<vec3i>* 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;
        void compute_inv(std::vector<uint32_t>& inv, std::vector<uint32_t>* p2c_ptr = 0, std::vector<uint32_t>* next_ptr = 0, std::vector<uint32_t>* prev_ptr = 0);
        uint32_t compute_c2e(const std::vector<uint32_t>& inv, std::vector<uint32_t>& c2e, std::vector<uint32_t>* e2c_ptr = 0);
        void compute_c2f(std::vector<uint32_t>& c2f);
};
 
template <typename T = float>
class CGV_API simple_mesh : public simple_mesh_base
{
public:
        typedef simple_mesh<T> mesh_type;
        typedef typename cgv::media::axis_aligned_box<T, 3> box_type;
        typedef typename cgv::math::fvec<T, 3> vec3;
        typedef typename cgv::math::fvec<T, 2> vec2;
        typedef typename cgv::math::fmat<T, 3, 3> mat3;
        typedef typename illum::surface_material::color_type clr_type;
        typedef typename illum::textured_surface_material mat_type;
        typedef cgv::type::uint32_type idx_type;
protected:
        friend class simple_mesh_obj_reader<T>;
        std::vector<vec3>  positions;
        std::vector<vec3>  normals;
        std::vector<vec2>  tex_coords;
 
        vec3 compute_normal(const vec3& p0, const vec3& p1, const vec3& p2);
public:
        simple_mesh(const simple_mesh<T>& sm);
        simple_mesh(const std::string& conway_notation = "");
        simple_mesh<T>& operator = (const simple_mesh<T>& sm);
        void clear();
 
        idx_type new_position(const vec3& p) { positions.push_back(p); return idx_type(positions.size()-1); }
        idx_type get_nr_positions() const { return idx_type(positions.size()); }
        vec3& position(idx_type pi) { return positions[pi]; }
        const vec3& position(idx_type pi) const { return positions[pi]; }
        const std::vector<vec3>& get_positions() const { return positions; }
 
        idx_type new_normal(const vec3& 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& normal(idx_type ni) { return normals[ni]; }
        const vec3& normal(idx_type ni) const { return normals[ni]; }
 
        idx_type new_tex_coord(const vec2& 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& tex_coord(idx_type ti) { return tex_coords[ti]; }
        const vec2& tex_coord(idx_type ti) const { return tex_coords[ti]; }
        void compute_face_normals();
        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 read(const std::string& file_name);
        bool write(const std::string& file_name) const;
        unsigned extract_vertex_attribute_buffer(
                const std::vector<idx_type>& vertex_indices,
                const std::vector<vec3i>& unique_triples,
                bool include_tex_coords, bool include_normals, 
                std::vector<T>& attrib_buffer, bool *include_colors_ptr = 0) const;
        void transform(const mat3& linear_transformation, const vec3& translation);
        void transform(const mat3& linear_transform, const vec3& translation, const mat3& inverse_linear_transform);
};
 
                }
        }
}
 
#include <cgv/config/lib_end.h>