Разбор строки

struct Face {
 std::vector<int> m_pos, m_uv, m_normal;
};

/// DEMO::Obj-Loader::version::0.3
///----------------------------------------------------------------------------|
/// C++20
/// source code: UTF-8
/// https://github.com/garykac/3d-cubes/blob/master/cube.obj
///----------------------------------------------------------------------------|
#include <iostream>
#include <sstream>
#include <vector>
#include <format>
 
#define l(a) std::cout << #a << " = " << (a) << '\n';
 
template <typename... TT> void Banner(TT&&... vals)
{   ((std::cout << vals << std::endl), ...);
}
 
 
///----------------------------------------------------------------------------|
/// Генератор входных данных.
///-------------------------------------------------------------------- GenTest:
struct GenTest
{   static std::string get(int n = 1)
    {   constexpr const char* ss
        {   R"(
# A 2 x 2 square mapped with a 1 x 1 square
# texture stretched to fit the square exactly.
mtllib master.mtl
 
v 0.100000 2.200000 0.300000
v 0.100000 0.200000 0.300000
v 2.100000 0.200000 0.300000
v 2.100000 2.200000 0.300000
vt 0.040000 1.000000
vt 0.040000 0.040000
vt 1.000000 0.040000
vt 1.000000 1.000000
 
# 4 vertices
usemtl wood
# The first number is the point and the second is the texture point
f 1/1 2/2 3/3 4/4
# 1 element
            )"
        };
 
        std::string s;
        while (n--) s += ss;
        return      s;
    }
};
 
 
///----------------------------------------------------------------------------|
/// Грань.
///----------------------------------------------------------------------- Face:
struct Face : std::array<std::vector<int>, 3>
{   enum EFACE
    {   POS,
        UV ,
        NORM
    };
};
 
struct Vertex : std::array<std::vector<float>, 3>
{   enum EVERTEX
    {   POS,
        UV ,
        NORM
    };
};
 
using cvf_t = const std::vector<float>;
void  out(std::ostream& o, cvf_t& m, std::string_view s, const size_t step)
{
    if(m.empty()) return;
    for(    size_t i = 0; i < m.size();)
    {   o << s;
        for(size_t j = 0; j < step && i < m.size(); ++j, ++i)
        {   o << std::format("{:6}", m[i]);
        }   o << '\n';
    }       o << '\n';
}
 
std::ostream& operator<<(std::ostream& o, const Vertex& f)
{   out(o, f[Vertex::POS ], "v  ---> ", 3);
    out(o, f[Vertex::UV  ], "vt ---> ", 2);
    out(o, f[Vertex::NORM], "vn ---> ", 3);
    return o;
}
 
std::ostream& operator<<(std::ostream& o, const Face& f)
{   o << "f-v : "; for(const auto n : f[Face::POS ]) {o << n << ' ';} o << '\n';
    o << "f-vt: "; for(const auto n : f[Face::UV  ]) {o << n << ' ';} o << '\n';
    o << "f-vn: "; for(const auto n : f[Face::NORM]) {o << n << ' ';} o << '\n';
    return o;
}
 
 
struct ObjLoader;
std::ostream& operator<<(std::ostream& o, const ObjLoader& m);
 
///----------------------------------------------------------------------------|
/// ObjLoader
///------------------------------------------------------------------ ObjLoader:
struct  ObjLoader : Face, Vertex
{       ObjLoader()
        {
        }
 
    ///------------------------------|
    /// Получить данные о Vertex.    |
    ///------------------------------:
    const std::vector<float>& getVertex(Vertex::EVERTEX i) const
    {   return (*static_cast<const Vertex*>(this))[size_t(i)];
    }
 
    ///------------------------------|
    /// Получить данные об индексах. |
    ///------------------------------:
    const std::vector<int>& getFace(Face::EFACE i) const
    {   return (*static_cast<const Face*>(this))[size_t(i)];
    }
 
    void go(std::istream&& is)
    {   size_t cnt{};
 
        Face  & F = *this;
        Vertex& V = *this;
 
        for(std::string s; std::getline(is, s); ++cnt)
        {
            if(s[0] != 'f')
            {
                const std::string_view a{s.substr(0, 2)};
 
                     if(a == "v ") go3d(s, V[Vertex::POS ]);
                else if(a == "vn") go3d(s, V[Vertex::NORM]);
                else if(a == "vt") go3d(s, V[Vertex::UV  ]);
                continue;
            }
 
            for(std::stringstream is(s); is >> s;)
            {   if(s[0] == 'f') continue;
                if(s[0] == ';') break;
 
                size_t i{};
                size_t d  ;
 
                if(!std::isdigit(s.back())) throw(cnt);
 
                for(std::stringstream is(s); std::getline(is, s, '/'); ++i)
                {   if(i > 2)              throw(cnt);
                    if(s.empty()&& i == 1) continue  ;
 
                    try
                    {   F[i].push_back(std::stoi(s, &d));
                        if(d != s.size())     throw(cnt);
                    }
                    catch(...)
                    {   throw(cnt);
                    }
                }
            }
        }
    }
 
    void go3d(std::string_view ss, std::vector<float>& res)
    {   size_t cnt{};
 
        std::string s;
 
        for(std::stringstream is(ss.data()); is >> s; ++cnt)
        {   if(0 == cnt) continue;
            size_t  d;
 
            try
            {   res.push_back(std::stod(s, &d));
                if(d != s.size())           throw(cnt);
            }
            catch(...)
            {   throw(cnt);
            }
        }
    }
 
    static void test()
    {   try
        {   ObjLoader    objLoader;
            objLoader.go(std::stringstream(GenTest::get()));
            std::cout << objLoader << '\n';
        }
        catch(size_t cnt)
        {   std::cout << std::format("ERROR: ObjLoader line={}...\n\n", cnt);
            return;
        }
 
        Banner(
            "///--------------------------|",
            "/// Тестирование УСПЕШНО!    |",
            "///--------------------------|\n");
    }
 
private:
};
 
std::ostream& operator<<(std::ostream& o, const ObjLoader& m)
{          o << (Vertex)(m);
           o << (Face  )(m);
    return o;
}
 
 
///----------------------------------------------------------------------------|
/// main
///----------------------------------------------------------------------- main:
int main()
{
    std::system        (  "chcp 65001>0");
    std::locale::global(std::locale("C"));
 
    Banner(
        "///--------------------------------|",
        "/// Привет, я есть OBJ-LOADER!     |",
        "///--------------------------------|\n");
 
    ObjLoader::test();
 
    std::cout << "ПРОГРАММА ЗАВЕРШИЛА РАБОТУ." << std::endl;
}

auto word = NextWord(str);
if (word.empty()) continue;
if (word == 'f')
 ParseFace(facets, str);

void ParseFace( std::vector<Face> & facets, std::string_view str )
{
 int done = 0;
 while (true) {
  auto word = NextWord(str);
  if (word.empty()) break;
  ++done;
  Face face;
  ParseIndices(face, word);
  facets.push_back(face);
 }
 if (!done)
  return Error(err_missed_face);
}

/// DEMO::Obj-Loader::version-0.4

/// DEMO::Obj-Loader::version-0.4
///----------------------------------------------------------------------------|
/// C++20
/// source code: UTF-8
/// Файл "cube.obj": https://github.com/garykac/3d-cubes/blob/master/cube.obj
///----------------------------------------------------------------------------|
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <format>
 
#define l(a) std::cout << #a << " = " << (a) << '\n';
 
template <typename... TT> void Banner(TT&&... vals)
{   ((std::cout << vals << std::endl), ...);
}
 
 
///----------------------------------------------------------------------------|
/// Генератор входных данных.
///-------------------------------------------------------------------- GenTest:
struct GenTest
{   static std::string get(int n = 1)
    {   constexpr const char* ss
        {
            /*01*/ "# A 2 x 2 square mapped with a 1 x 1 square\n"
            /*02*/ "# texture stretched to fit the square exactly.\n"
            /*03*/ "mtllib master.mtl\n"
            /*04*/ "#---------------------------\n"
            /*05*/ "v 0.100000 2.200000 0.300000\n"
            /*06*/ "v 0.100000 0.200000 0.300000\n"
            /*07*/ "v 2.100000 0.200000 0.300000\n"
            /*08*/ "v 2.100000 2.200000 0.300000\n"
            /*09*/ "vt 0.04    0.040000\n"
            /*10*/ "vt 1.00    0.040000\n"
            /*11*/ "vt 1.00    1.000000\n"
            /*12*/ "vt 0.04 \t 1.000000\n"
            /*13*/ "#---------------------------\n"
            /*14*/ "# 4 vertices\n"
            /*15*/ "usemtl wood\n"
            /*16*/ "# The first number is point and second is the texture point\n"
            /*17*/ "f 1/1 2/2 3/3 4/4\n"
            /*18*/ "# 1 element\n"
        };
 
        std::string s;
        while (n--) s += ss;
        return      s;
    }
};
 
 
///----------------------------------------------------------------------------|
/// Вертексы и индексы.
///---------------------------------------------------------------------- BaseV:
template<typename T>
struct BaseV : std::array<std::vector<T>, 3>
{   enum EFACE
    {    POS,
         UV ,
         NORM
    };
};
 
struct Face   : BaseV<int  > { };
struct Vertex : BaseV<float> { };
 
 
using cvf_t = const std::vector<float>;
void  out(std::ostream& o, cvf_t& m, std::string_view s, const size_t step)
{
    if (m.empty()) return;
    for(    size_t i = 0; i < m.size();)
    {   o << s;
        for(size_t j = 0; j < step && i < m.size(); ++j, ++i)
        {   o << std::format("{:6}", m[i]);
        }   o << '\n';
    }       o << '\n';
}
 
std::ostream& operator<<(std::ostream& o, const Vertex& v)
{   out(o, v[Vertex::POS ], "v  ---> ", 3);
    out(o, v[Vertex::UV  ], "vt ---> ", 2);
    out(o, v[Vertex::NORM], "vn ---> ", 3);
    return o;
}
 
std::ostream& operator<<(std::ostream& o, const Face& f)
{   o << "f-v : "; for(const auto n : f[Face::POS ]) {o << n << ' ';} o << '\n';
    o << "f-vt: "; for(const auto n : f[Face::UV  ]) {o << n << ' ';} o << '\n';
    o << "f-vn: "; for(const auto n : f[Face::NORM]) {o << n << ' ';} o << '\n';
    return o;
}
 
 
///----------------------------------------------------------------------------|
/// ObjLoader
///------------------------------------------------------------------ ObjLoader:
struct  ObjLoader ; std::ostream& operator<<(std::ostream&, const ObjLoader&);
struct  ObjLoader : Face, Vertex
{       ObjLoader()
        {
        }
 
    std::string name;
 
    ///------------------------------|
    /// Получить данные о Vertex.    |
    ///------------------------------:
    const std::vector<float>& getVertex(Face::BaseV::EFACE i) const
    {   return (*static_cast<const Vertex*>(this))[size_t(i)];
    }
 
    ///------------------------------|
    /// Получить данные об индексах. |
    ///------------------------------:
    const std::vector<int>& getFace(Vertex::BaseV::EFACE i) const
    {   return (*static_cast<const Face*>(this))[size_t(i)];
    }
 
    void go(std::istream& is)
    {   cnt = 0;
 
        Face  & F = *this;
        Vertex& V = *this;
 
        std::getline(is, name);
 
        for(std::string s; std::getline(is, s); ++cnt)
        {
            if(s[0] != 'f')
            {
                const std::string_view a{s.substr(0, 2)};
 
                     if(a == "v ") go3d(s, V[Vertex::POS ]);
                else if(a == "vn") go3d(s, V[Vertex::NORM]);
                else if(a == "vt") go3d(s, V[Vertex::UV  ]);
                continue;
            }
 
            for(std::stringstream is(s); is >> s;)
            {   if(s[0] == 'f') continue;
                if(s[0] == '#') break;
 
                size_t i{};
                size_t d  ;
 
                if(!std::isdigit(s.back())) throw(cnt);
 
                for(std::stringstream is(s); std::getline(is, s, '/'); ++i)
                {
                    if(i > 2)              throw(cnt);
                    if(s.empty()&& i == 1) continue  ;
 
                    try
                    {   F[i].push_back(std::stoi(s, &d));
                        if(d != s.size())     throw(cnt);
                    }
                    catch(...)
                    {   throw(cnt);
                    }
                }
            }
        }
    }
 
    void go3d(std::string_view ss, std::vector<float>& res)
    {
        std::string s; std::stringstream is(ss.data()); is >> s;
 
        while(is >> s && s[0] != '#')
        {
            try
            {   size_t  d;
                res.push_back(std::stod(s, &d));
                if(d != s.size())    throw(cnt);
            }
            catch(...)
            {   throw(cnt);
            }
        }
    }
 
    static void test(std::istream&& is = std::stringstream(GenTest::get()))
    {
        if(!is.good())
        {   std::cout << "ERROR: В потоке ничего нет ...\n\n"; return;
        }
 
        try
        {   ObjLoader    objLoader;
            objLoader.go(is);
            std::cout << objLoader << '\n';
        }
        catch(size_t cnt)
        {   std::cout << std::format("ERROR: ObjLoader line={}...\n\n", ++cnt);
            return;
        }
 
        Banner(
            "///--------------------------|",
            "/// Тестирование УСПЕШНО!    |",
            "///--------------------------|\n");
    }
 
private:
    size_t cnt;
};
 
std::ostream& operator<<(std::ostream& o, const ObjLoader& obj)
{          o << std::format("{}\n\n", obj.name);
           o << (Vertex)(obj);
           o << (Face  )(obj);
    return o;
}
 
 
///----------------------------------------------------------------------------|
/// main
///----------------------------------------------------------------------- main:
int main()
{
    std::system        (  "chcp 65001>0");
    std::locale::global(std::locale("C"));
 
    Banner(
        "///--------------------------------|",
        "/// Привет, я есть OBJ-LOADER!     |",
        "///--------------------------------|\n");
 
    ObjLoader::test(std::ifstream("cube.obj"));
 
    std::cout << "ПРОГРАММА ЗАВЕРШИЛА РАБОТУ." << std::endl;
    std::cin.get();
}

const char* const NAMEPROJ{"DEMO::Obj-Loader::version-0.5"};
///----------------------------------------------------------------------------|
/// C++20
/// source code: UTF-8
/// Файл "cube.obj": https://github.com/garykac/3d-cubes/blob/master/cube.obj
///----------------------------------------------------------------------------|
#include <iostream>
#include <charconv>
#include <sstream>
#include <fstream>
#include <vector>
#include <format>
 
#define l(a) std::cout << #a << " = " << (a) << '\n';
 
///---------|
/// my lib  |
///---------:
namespace myl
{
    template <typename... T> void banner(T&&... vals)
    {   ((std::cout << vals << std::endl), ...);
    }
 
    template<typename T>
    static std::streamsize getStreamSize(T& stream)
    {
        std::streampos current_pos = stream.tellg();
 
        stream.seekg(0, std::ios::end);
        std::streampos end_pos = stream.tellg();
 
        stream.seekg(current_pos);
        return end_pos;
    }
}
 
 
///----------------------------------------------------------------------------|
/// Генератор входных данных.
///-------------------------------------------------------------------- GenTest:
struct GenTest
{   static std::string get(int n = 1)
    {   constexpr const char* ss
        {
            /*01*/ "# A 2 x 2 square mapped with a 1 x 1 square\n"
            /*02*/ "# texture stretched to fit the square exactly.\n"
            /*03*/ "mtllib master.mtl\n"
            /*04*/ "#---------------------------\n"
            /*05*/ "v 0.100000 2.200000 0.300000\n"
            /*06*/ "v 0.100000 0.200000 0.300000\n"
            /*07*/ "v 2.100000 0.200000 0.300000\n"
            /*08*/ "v 2.100000 2.200000 0.300000\n"
            /*09*/ "vt 0.04    0.040000\n"
            /*10*/ "vt 1.00    0.040000\n"
            /*11*/ "vt 1.00    1.000000\n"
            /*12*/ "vt 0.04 \t 1.000000\n"
            /*13*/ "#---------------------------\n"
            /*14*/ "# 4 vertices\n"
            /*15*/ "usemtl wood\n"
            /*16*/ "# The first number is point and second is texture point\n"
            /*17*/ "f 1/1 2/2 3/3 4/4 #qwerty\n"
            /*18*/ "# 1 element\n"
        };
 
        constexpr size_t len = std::char_traits<char>::length(ss);
        l(len)
 
        std::string s;
        while (n--) s += ss;
        return      s;
    }
};
 
 
///----------------------------------------------------------------------------|
/// Хранилища для Вертексов и Индексов.
///---------------------------------------------------------------------- BaseV:
template<typename T>
struct BaseV : std::array<std::vector<T>, 3>
{   enum EFACE
    {    POS,
         UV ,
         NORM
    };
 
    void reserve(size_t n)
    {   for(auto& m : *this) { m.clear(); m.reserve(n); }
    }
};
 
struct Face   : BaseV<int  > { };
struct Vertex : BaseV<float> { };
 
 
using cvf_t = const std::vector<float>;
void  out(std::ostream& o, cvf_t& m, std::string_view s, const size_t step)
{
    if (m.empty()) return;
    for(    size_t i = 0; i < m.size();)
    {   o << s;
        for(size_t j = 0; j < step && i < m.size(); ++j, ++i)
        {   o << std::format("{:6}", m[i]);
        }   o << '\n';
    }       o << '\n';
}
 
std::ostream& operator<<(std::ostream& o, const Vertex& v)
{   out(o, v[Vertex::POS ], "v  ---> ", 3);
    out(o, v[Vertex::UV  ], "vt ---> ", 2);
    out(o, v[Vertex::NORM], "vn ---> ", 3);
    return o;
}
 
std::ostream& operator<<(std::ostream& o, const Face& f)
{   o << "f-v : "; for(const auto n : f[Face::POS ]) {o << n << ' ';} o << '\n';
    o << "f-vt: "; for(const auto n : f[Face::UV  ]) {o << n << ' ';} o << '\n';
    o << "f-vn: "; for(const auto n : f[Face::NORM]) {o << n << ' ';} o << '\n';
    return o;
}
 
template<typename T>
std::ostream& operator<<(std::ostream& o, const std::vector<T>& v)
{   for(const auto n : v) o << n << ", "; return o;
}
 
 
///----------------------------------------------------------------------------|
/// ObjLoader
///------------------------------------------------------------------ ObjLoader:
struct  ObjLoader ; std::ostream& operator<<(std::ostream&, const ObjLoader&);
struct  ObjLoader : Face, Vertex
{       ObjLoader()
        {
        }
 
    std::string name;
 
    ///------------------------------|
    /// Получить данные о Vertex.    |
    ///------------------------------:
    const std::vector<float>& get(Vertex::BaseV::EFACE i) const
    {   return (*static_cast<const Vertex*>(this))[size_t(i)];
    }
 
    ///------------------------------|
    /// Получить данные об индексах. |
    ///------------------------------:
    const std::vector<int>& get(Face::BaseV::EFACE i) const
    {   return (*static_cast<const Face*>(this))[size_t(i)];
    }
 
    void go(std::istream& is)
    {
        if(!is.good())
        {   std::cout << "ERROR: В потоке ничего нет ...\n";
            throw(1u);
        }
 
        cnt = 2;
 
        Face  & F = *this;
        Vertex& V = *this;
        {
            const size_t sz = myl::getStreamSize(is);
            F.reserve   (sz / 5);
            V.reserve   (sz / 5);
        }
 
        std::getline(is, name);
 
        for(std::string s; std::getline(is, s); ++cnt)
        {
            if(s[0] != 'f')
            {
                const std::string_view a{s.substr(0, 2)};
 
                     if(a == "v ") go3d(s, V[Vertex::POS ]);
                else if(a == "vn") go3d(s, V[Vertex::NORM]);
                else if(a == "vt") go3d(s, V[Vertex::UV  ]);
                continue;
            }
 
            std::stringstream is(s); is >> s;
 
            while( is >> s && s[0] != '#' )
            {   parseNumbers(s);
            }
        }
    }
 
    void go3d(std::string_view ss, std::vector<float>& res)
    {
        std::string s; std::stringstream is(ss.data()); is >> s;
 
        while(is >> s && s[0] != '#')
        {
            try
            {   size_t  d;
                res.push_back(std::stod(s, &d));
                if(d != s.size())    throw(cnt);
            }
            catch(...)
            {   throw(cnt);
            }
        }
    }
 
    void parseNumbers(std::string_view s)
    {
        Face& F = *this;
        const char* curr = &s.front();
        const char* end  = curr + s.size();
 
        for(size_t i{}; ; ++i, ++curr)
        {
            if(i  > 2) throw(cnt);
            if(i == 1 && *curr == '/') continue;
 
            F[i].push_back(0);
            auto res     = std::from_chars(curr, end, F[i].back());
            if(  res.ec != std::errc ()) throw(cnt);
            if( (curr = res.ptr) == end) break;
            if( *curr   != '/' )         throw(cnt);
        }
    }
 
    static void test(std::istream&& is = std::stringstream(GenTest::get()))
    {
        try
        {   ObjLoader    objLoader;
            objLoader.go(is);
            std::cout << objLoader << '\n';
 
            l(objLoader.get(Vertex::POS ))
            l(objLoader.get(Vertex::UV  ))
            l(objLoader.get(Vertex::NORM))
            l(objLoader.get(Face  ::POS ))
        }
        catch(unsigned cnt)
        {   std::cout << std::format("ERROR: ObjLoader line={}...\n\n", cnt);
            return;
        }
 
        myl::banner(
        "///--------------------------|",
        "/// Тестирование УСПЕШНО!    |",
        "///--------------------------|\n");
    }
 
private:
    unsigned cnt;
};
 
std::ostream& operator<<(std::ostream& o, const ObjLoader& obj)
{          o << std::format("{}\n\n", obj.name);
           o << (Vertex)(obj);
           o << (Face  )(obj);
    return o;
}
 
 
///----------------------------------------------------------------------------|
/// main
///----------------------------------------------------------------------- main:
int main()
{
    std::system        (  "chcp 65001>0");
    std::locale::global(std::locale("C"));
 
    std::cout
    <<  "///-----------------------------------------------|\n"
    <<  "/// Привет, я есть "     << NAMEPROJ <<        "  |\n"
    <<  "///-----------------------------------------------|\n\n";
 
/// ObjLoader::test(std::ifstream("cube.obj"));
    ObjLoader::test();
 
    std::cout << "ПРОГРАММА ЗАВЕРШИЛА РАБОТУ." << std::endl;
    std::cin.get();
}