model_viewer::loaders::ObjLoader Class Reference

Class for loading OBJ models. More...

#include <ObjLoader.hpp>

Inheritance diagram for model_viewer::loaders::ObjLoader:

Collaboration diagram for model_viewer::loaders::ObjLoader:

Public Member Functions
	ObjLoader ()
	Constructor.
	~ObjLoader () override=default
	Destructor.
bool	loadModel (const std::string &filepath) override
	Load an OBJ model from a file.
QQuick3DGeometry *	geometry () const override
	Get the geometry of the loaded model.
material::MTLMaterial *	material () const override
	Get the material of the loaded model.
const std::vector< geometry::Vector3 > &	getVertices () const
const std::vector< geometry::TextureCoordinate > &	getTextureCoords () const
const std::vector< geometry::Vector3 > &	getNormals () const
const std::vector< geometry::FaceIndex > &	getFaces () const
const std::string &	getModelPath () const
Public Member Functions inherited from model_viewer::loaders::ILoader
virtual	~ILoader ()=default
	Virtual destructor.

Private Member Functions
void	reset ()
	Reset the OBJ loader state.
void	parseModel (std::ifstream &file)
	Parse an OBJ file line by line.
void	setModelData ()
	Set the model data to the geometry.
void	resetObj ()
	Reset the OBJ model state.
void	parseVertice (const std::string &line)
	Parse a vertice line from the OBJ file.
void	parseNormal (const std::string &line)
	Parse a normal vertice line from the OBJ file.
void	parseTextureCoordinate (const std::string &line)
	Parse a texture coordinate vertice line from the OBJ file.
void	parseFace (const std::string &line)
	Parse a face line from the OBJ file.
geometry::FaceIndex	parseFaceIndex (const std::string &token)
	Parse a face index token from the OBJ file.
void	retrieveMaterial (const std::string &line)
	Retrieve material from a material library line and call material's parsing method.

Private Attributes
std::vector< geometry::Vector3 >	_vertices
	Vertices of the model.
std::vector< geometry::TextureCoordinate >	_textureCoords
	Texture coordinates of the model.
std::vector< geometry::Vector3 >	_normals
	Normals of the model.
std::vector< geometry::FaceIndex >	_faces
	Faces of the model.
std::string	_modelPath
	Path to the model file.
std::unordered_map< std::string, std::function< void(const std::string &)> >	_parseFunctions
	Map of parsing functions for different OBJ line prefixes.
std::unique_ptr< geometry::ObjGeometry >	_geometry
	Geometry of the model.
std::unique_ptr< material::MTLMaterial >	_material
	Material of the model.

Detailed Description

Class for loading OBJ models.

Constructor & Destructor Documentation

ObjLoader()

model_viewer::loaders::ObjLoader::ObjLoader

(

)

Constructor.

    : _geometry(std::make_unique<geometry::ObjGeometry>()),
      _material(std::make_unique<material::MTLMaterial>()) {
    _parseFunctions = {
        {"v", [this](const std::string &l) { parseVertice(l); }},
        {"vn", [this](const std::string &l) { parseNormal(l); }},
        {"vt", [this](const std::string &l) { parseTextureCoordinate(l); }},
        {"f", [this](const std::string &l) { parseFace(l); }},
        {"mtllib", [this](const std::string &l) { retrieveMaterial(l); }},
    };
}

References _parseFunctions, parseFace(), parseNormal(), parseTextureCoordinate(), parseVertice(), and retrieveMaterial().

Here is the call graph for this function:

~ObjLoader()

model_viewer::loaders::ObjLoader::~ObjLoader ( )

overridedefault

Destructor.

Member Function Documentation

geometry()

QQuick3DGeometry * model_viewer::loaders::ObjLoader::geometry ( ) const

inlineoverridevirtual

Get the geometry of the loaded model.

Returns

Geometry of the loaded model

Implements model_viewer::loaders::ILoader.

{ return _geometry.get(); };

References _geometry.

getFaces()

const std::vector< geometry::FaceIndex > & model_viewer::loaders::ObjLoader::getFaces ( ) const

inline

{ return _faces; }

References _faces.

getModelPath()

const std::string & model_viewer::loaders::ObjLoader::getModelPath ( ) const

inline

{ return _modelPath; }

References _modelPath.

getNormals()

const std::vector< geometry::Vector3 > & model_viewer::loaders::ObjLoader::getNormals ( ) const

inline

                                                         {
        return _normals;
    }

References _normals.

getTextureCoords()

const std::vector< geometry::TextureCoordinate > & model_viewer::loaders::ObjLoader::getTextureCoords ( ) const

inline

                                                                         {
        return _textureCoords;
    }

References _textureCoords.

getVertices()

const std::vector< geometry::Vector3 > & model_viewer::loaders::ObjLoader::getVertices ( ) const

inline

                                                          {
        return _vertices;
    }

References _vertices.

loadModel()

bool model_viewer::loaders::ObjLoader::loadModel ( const std::string & filepath )

overridevirtual

Load an OBJ model from a file.

Parameters

filepath

Path to the OBJ file

Returns

Boolean indicating whether the model was loaded successfully

Todo

Add support for groups and multiple materials

Implements model_viewer::loaders::ILoader.

                                                   {
    reset();
    _modelPath = string_helpers::normalizePath(filepath);
    std::ifstream in(_modelPath, std::ios::in);
    if (!in.is_open()) {
        std::cerr << "ObjLoader: Could not open file " << _modelPath << ": "
                  << std::strerror(errno) << std::endl;
        return false;
    }
    parseModel(in);
    setModelData();
    return true;
}

References _modelPath, model_viewer::string_helpers::normalizePath(), parseModel(), reset(), and setModelData().

Here is the call graph for this function:

material()

material::MTLMaterial * model_viewer::loaders::ObjLoader::material ( ) const

inlineoverridevirtual

Get the material of the loaded model.

Returns

Material of the loaded model

Implements model_viewer::loaders::ILoader.

                                                   {
        return _material.get();
    };

References _material.

parseFace()

void model_viewer::loaders::ObjLoader::parseFace ( const std::string & line )

private

Parse a face line from the OBJ file.

Parameters

line	Line to parse

                                               {
    std::istringstream f(line.substr(2));
    std::string token;
    std::vector<geometry::FaceIndex> face;
    while (f >> token) face.push_back(parseFaceIndex(token));
    for (size_t i = 1; i + 1 < face.size(); ++i) {
        this->_faces.push_back(face[0]);
        this->_faces.push_back(face[i]);
        this->_faces.push_back(face[i + 1]);
    }
}

References _faces, and parseFaceIndex().

Referenced by ObjLoader().

Here is the call graph for this function:

Here is the caller graph for this function:

parseFaceIndex()

geometry::FaceIndex model_viewer::loaders::ObjLoader::parseFaceIndex ( const std::string & token )

private

Parse a face index token from the OBJ file.

Parameters

token

Token to parse

Returns

Parsed FaceIndex struct

                                                                  {
    geometry::FaceIndex idx;
    std::sscanf(token.c_str(), "%d/%d/%d", &idx.v, &idx.vt, &idx.vn);
 
    if (token.find("//") != std::string::npos) {
        std::sscanf(token.c_str(), "%d//%d", &idx.v, &idx.vn);
        idx.vt = 0;
    } else if (token.find('/') != std::string::npos &&
               std::ranges::count(token, '/') == 1) {
        std::sscanf(token.c_str(), "%d/%d", &idx.v, &idx.vt);
        idx.vn = 0;
    } else if (token.find('/') == std::string::npos) {
        std::sscanf(token.c_str(), "%d", &idx.v);
    }
    return idx;
}

References model_viewer::geometry::FaceIndex::v, model_viewer::geometry::FaceIndex::vn, and model_viewer::geometry::FaceIndex::vt.

Referenced by parseFace().

Here is the caller graph for this function:

parseModel()

void model_viewer::loaders::ObjLoader::parseModel ( std::ifstream & file )

private

Parse an OBJ file line by line.

Parameters

file	Input file stream to parse

Todo

Optimize parsing of the model

                                            {
    std::string line;
    while (std::getline(file, line)) {
        const auto pos = line.find(' ');
        const std::string lineStart =
            string_helpers::trim_copy(line.substr(0, pos));
        if (_parseFunctions.contains(lineStart))
            _parseFunctions.at(lineStart)(line);
    }
}

References _parseFunctions, and model_viewer::string_helpers::trim_copy().

Referenced by loadModel().

Here is the call graph for this function:

Here is the caller graph for this function:

parseNormal()

void model_viewer::loaders::ObjLoader::parseNormal ( const std::string & line )

private

Parse a normal vertice line from the OBJ file.

Parameters

line	Line to parse

                                                 {
    float x, y, z;
    if (std::sscanf(line.c_str() + 2, "%f %f %f", &x, &y, &z) < 3)
        std::cerr << "Invalid normal at line " << line << std::endl;
    else
        this->_normals.push_back({x, y, z});
}

References _normals.

Referenced by ObjLoader().

Here is the caller graph for this function:

parseTextureCoordinate()

void model_viewer::loaders::ObjLoader::parseTextureCoordinate ( const std::string & line )

private

Parse a texture coordinate vertice line from the OBJ file.

Parameters

line	Line to parse

                                                            {
    float u, v;  // Missing w
    if (std::sscanf(line.c_str() + 2, "%f %f", &u, &v) < 2)
        std::cerr << "Invalid normal at line " << line << std::endl;
    else
        this->_textureCoords.push_back({u, v});
}

References _textureCoords.

Referenced by ObjLoader().

Here is the caller graph for this function:

parseVertice()

void model_viewer::loaders::ObjLoader::parseVertice ( const std::string & line )

private

Parse a vertice line from the OBJ file.

Parameters

line	Line to parse

                                                  {
    float x, y, z;  // Missing optional w
    if (std::sscanf(line.c_str() + 2, "%f %f %f", &x, &y, &z) < 3)
        std::cerr << "Invalid vertice at line " << line << std::endl;
    else
        this->_vertices.push_back({x, y, z});
}

References _vertices.

Referenced by ObjLoader().

Here is the caller graph for this function:

reset()

void model_viewer::loaders::ObjLoader::reset ( )

private

Reset the OBJ loader state.

                      {
    resetObj();
    _material->resetMaterial();
}

References _material, and resetObj().

Referenced by loadModel().

Here is the call graph for this function:

Here is the caller graph for this function:

resetObj()

void model_viewer::loaders::ObjLoader::resetObj ( )

private

Reset the OBJ model state.

                         {
    _faces.clear();
    _vertices.clear();
    _normals.clear();
    _textureCoords.clear();
}

References _faces, _normals, _textureCoords, and _vertices.

Referenced by reset().

Here is the caller graph for this function:

retrieveMaterial()

void model_viewer::loaders::ObjLoader::retrieveMaterial ( const std::string & line )

private

Retrieve material from a material library line and call material's parsing method.

Parameters

line	Line to parse

                                                      {
    const std::string name =
        string_helpers::trim_copy(line.substr(sizeof("mtllib")));
    const std::filesystem::path path =
        std::filesystem::path(_modelPath).parent_path() / name;
    _material->parseMTL(path.string());
}

References _material, _modelPath, and model_viewer::string_helpers::trim_copy().

Referenced by ObjLoader().

Here is the call graph for this function:

Here is the caller graph for this function:

setModelData()

void model_viewer::loaders::ObjLoader::setModelData ( )

private

Set the model data to the geometry.

                             {
    std::vector<geometry::Vector3> vVector;
    std::vector<geometry::TextureCoordinate> vtVector;
    std::vector<geometry::Vector3> vnVector;
    for (auto [v, vt, vn] : _faces) {
        if (!_vertices.empty() && v != 0) {
            const int vIdx = v > 0 ? v - 1 : _vertices.size() + v;
            vVector.push_back(_vertices[vIdx]);
        }
        if (!_textureCoords.empty() && vt != 0) {
            const int vtIdx = vt > 0 ? vt - 1 : _vertices.size() + vt;
            vtVector.push_back(_textureCoords[vtIdx]);
        }
        if (!_normals.empty() && vn != 0) {
            const int vnIdx = vn > 0 ? vn - 1 : _vertices.size() + vn;
            vnVector.push_back(_normals[vnIdx]);
        }
    }
    _vertices = vVector;
    _textureCoords = vtVector;
    _normals = vnVector;
    _geometry->setMesh(_vertices, _normals, _textureCoords);
}

References _faces, _geometry, _normals, _textureCoords, and _vertices.

Referenced by loadModel().

Here is the caller graph for this function:

Member Data Documentation

_faces

std::vector<geometry::FaceIndex> model_viewer::loaders::ObjLoader::_faces

private

Faces of the model.

Referenced by getFaces(), parseFace(), resetObj(), and setModelData().

_geometry

std::unique_ptr<geometry::ObjGeometry> model_viewer::loaders::ObjLoader::_geometry

private

Geometry of the model.

Referenced by geometry(), and setModelData().

_material

std::unique_ptr<material::MTLMaterial> model_viewer::loaders::ObjLoader::_material

private

Material of the model.

Referenced by material(), reset(), and retrieveMaterial().

_modelPath

std::string model_viewer::loaders::ObjLoader::_modelPath

private

Path to the model file.

Referenced by getModelPath(), loadModel(), and retrieveMaterial().

_normals

std::vector<geometry::Vector3> model_viewer::loaders::ObjLoader::_normals

private

Normals of the model.

Referenced by getNormals(), parseNormal(), resetObj(), and setModelData().

_parseFunctions

std::unordered_map<std::string, std::function<void(const std::string &)> > model_viewer::loaders::ObjLoader::_parseFunctions

private

Map of parsing functions for different OBJ line prefixes.

Referenced by ObjLoader(), and parseModel().

_textureCoords

std::vector<geometry::TextureCoordinate> model_viewer::loaders::ObjLoader::_textureCoords

private

Texture coordinates of the model.

Referenced by getTextureCoords(), parseTextureCoordinate(), resetObj(), and setModelData().

_vertices

std::vector<geometry::Vector3> model_viewer::loaders::ObjLoader::_vertices

private

Vertices of the model.

Referenced by getVertices(), parseVertice(), resetObj(), and setModelData().

---

The documentation for this class was generated from the following files:

• /github/workspace/include/Loaders/Obj/ObjLoader.hpp
• /github/workspace/src/Loaders/Obj/ObjLoader.cpp