obj_reader.h

#pragma once
 
#include <cgv/math/fvec.h>
#include <cgv/media/illum/obj_material.hh>
#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);
        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_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 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 crd_type;
        typedef cgv::math::fvec<T,2> v2d_type;
        typedef cgv::math::fvec<T,3> v3d_type;
        static bool is_double(const char* begin, const char* end, crd_type& value);
protected:
        v2d_type   parse_v2d(const std::vector<cgv::utils::token>& t) const;
        v3d_type   parse_v3d(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 v3d_type& p);
        virtual void process_texcoord(const v2d_type& t);
        virtual void process_normal(const v3d_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>