obj_reader.h

#pragma once
 
#include <cgv/math/fvec.h>
#include <cgv/media/illum/obj_material.h>
#include <cgv/utils/tokenizer.h>
#include <set>
#include <map>
#include <vector>
#include <string>
 
#include <cgv/media/lib_begin.h>
 
namespace cgv {
    namespace media {
        namespace mesh {
 
class CGV_API obj_reader_base
{
public:
    typedef illum::obj_material::color_type color_type;
protected:
    unsigned group_index;
    unsigned nr_groups;
    unsigned material_index;
    unsigned nr_materials;
    std::map<std::string, unsigned> material_index_lut;
    color_type parse_color(const std::vector<cgv::utils::token>& t, unsigned off = 0) const;
    int minus;
    unsigned nr_normals, nr_texcoords;
    bool have_default_material;
    std::set<std::string> mtl_lib_files;
    void parse_face(const std::vector<cgv::utils::token>& tokens, bool is_line = false);
    void parse_material(const std::vector<cgv::utils::token>& tokens);
    virtual void parse_and_process_vertex(const std::vector<cgv::utils::token>& tokens) = 0;
    virtual void parse_and_process_normal(const std::vector<cgv::utils::token>& tokens) = 0;
    virtual void parse_and_process_texcoord(const std::vector<cgv::utils::token>& tokens) = 0;
 
    std::string path_name;
    unsigned get_current_group() const;
    unsigned get_current_material() const;
 
    virtual void process_comment(const std::string& comment);
    virtual void process_color(const color_type& c);
    void convert_to_positive(unsigned vcount, int *vertices,
        int *texcoords, int *normals,
        unsigned v, unsigned n, unsigned t);
    virtual void process_line(unsigned vcount, int *vertices,
        int *texcoords = 0, int *normals = 0);
    virtual void process_face(unsigned vcount, int* vertices,
        int* texcoords = 0, int* normals = 0);
    virtual void process_group(const std::string& name, const std::string& parameters);
    virtual void process_material(const cgv::media::illum::obj_material& mtl, unsigned idx);
public:
    obj_reader_base();
    virtual bool parse_obj(const std::string& content, const std::string path_name = "");
    virtual bool read_obj(const std::string& file_name);
    virtual bool read_mtl(const std::string& file_name);
    virtual void clear();
};
 
template <typename T>
class CGV_API obj_reader_generic : public obj_reader_base
{
public:
    typedef T coord_type;
    typedef cgv::math::fvec<T,2> vec2_type;
    typedef cgv::math::fvec<T,3> vec3_type;
    static bool is_double(const char* begin, const char* end, coord_type& value);
protected:
    vec2_type   parse_vec2(const std::vector<cgv::utils::token>& t) const;
    vec3_type   parse_vec3(const std::vector<cgv::utils::token>& t) const;
    void parse_and_process_vertex(const std::vector<cgv::utils::token>& tokens);
    void parse_and_process_normal(const std::vector<cgv::utils::token>& tokens);
    void parse_and_process_texcoord(const std::vector<cgv::utils::token>& tokens);
 
    virtual void process_vertex(const vec3_type& p);
    virtual void process_texcoord(const vec2_type& t);
    virtual void process_normal(const vec3_type& n);
public:
    obj_reader_generic();
};
 
typedef obj_reader_generic<float>  obj_readerf;
typedef obj_reader_generic<double> obj_readerd;
typedef obj_reader_generic<double> obj_reader;
 
        }
    }
}
 
#include <cgv/config/lib_end.h>