model_viewer::geometry::ObjGeometry Class Reference

Class representing the geometry of an OBJ model. More...

#include <ObjGeometry.hpp>

Inheritance diagram for model_viewer::geometry::ObjGeometry:

Collaboration diagram for model_viewer::geometry::ObjGeometry:

Public Member Functions
	ObjGeometry (QQuick3DObject *parent=nullptr)
	Constructor.
void	setMesh (const std::vector< Vector3 > &vertices, const std::vector< Vector3 > &normals, const std::vector< TextureCoordinate > &textureCoords)
	Set the mesh data.

Private Member Functions
void	setModelData (const std::vector< Vector3 > &vertices, const std::vector< Vector3 > &normals, const std::vector< TextureCoordinate > &textureCoords)
	Set the model data to the geometry.
void	configureVertexLayout ()
	Configure the vertex layout of the geometry based on the data.

Private Attributes
bool	_hasNormals = false
	Whether the geometry contains normals.
bool	_hasTextureCoords = false
	Whether the geometry contains texture coordinates.

Detailed Description

Class representing the geometry of an OBJ model.

Constructor & Destructor Documentation

ObjGeometry()

model_viewer::geometry::ObjGeometry::ObjGeometry ( QQuick3DObject * parent = nullptr )

explicit

Constructor.

Parameters

parent

Parent QQuick3DObject, nullptr by default

: QQuick3DGeometry(parent) {}

Member Function Documentation

configureVertexLayout()

void model_viewer::geometry::ObjGeometry::configureVertexLayout ( )

private

Configure the vertex layout of the geometry based on the data.

                                        {
    int stride = 3 * sizeof(float);
    int offset = 0;
    addAttribute(Attribute::PositionSemantic, offset, Attribute::F32Type);
    offset += 3 * sizeof(float);
    if (_hasNormals) {
        stride += 3 * sizeof(float);
        addAttribute(Attribute::NormalSemantic, offset, Attribute::F32Type);
        offset += 3 * sizeof(float);
    }
    if (_hasTextureCoords) {
        stride += 2 * sizeof(float);
        addAttribute(Attribute::TexCoord0Semantic, offset, Attribute::F32Type);
        offset += 2 * sizeof(float);
    }
    setStride(stride);
    setPrimitiveType(PrimitiveType::Triangles);
}

References _hasNormals, and _hasTextureCoords.

Referenced by setMesh().

Here is the caller graph for this function:

setMesh()

void model_viewer::geometry::ObjGeometry::setMesh	(	const std::vector< Vector3 > &	vertices,
		const std::vector< Vector3 > &	normals,
		const std::vector< TextureCoordinate > &	textureCoords )

Set the mesh data.

Parameters

vertices	Vertices of the model
normals	Normals of the model
textureCoords	Texture coordinates of the model

                                                                             {
    clear();
    _hasNormals = !normals.empty();
    _hasTextureCoords = !textureCoords.empty();
    setModelData(vertices, normals, textureCoords);
    configureVertexLayout();
    update();
}

References _hasNormals, _hasTextureCoords, configureVertexLayout(), and setModelData().

Here is the call graph for this function:

setModelData()

void model_viewer::geometry::ObjGeometry::setModelData ( const std::vector< Vector3 > & vertices, const std::vector< Vector3 > & normals, const std::vector< TextureCoordinate > & textureCoords )

private

Set the model data to the geometry.

Parameters

vertices	Vertices of the model
normals	Normals of the model
textureCoords	Texture coordinates of the model

                                                       {
    QByteArray vertexData;
 
    const qsizetype vertexSize = static_cast<qsizetype>(vertices.size()) *
                                 static_cast<qsizetype>(sizeof(Vector3));
    const qsizetype normalSize = static_cast<qsizetype>(normals.size()) *
                                 static_cast<qsizetype>(sizeof(Vector3));
    const qsizetype textureSize =
        static_cast<qsizetype>(textureCoords.size()) *
        static_cast<qsizetype>(sizeof(TextureCoordinate));
    vertexData.resize(vertexSize + normalSize + textureSize);
    float *vertexDataPointer = reinterpret_cast<float *>(vertexData.data());
    for (size_t i = 0; i < vertices.size(); ++i) {
        const auto &[vx, vy, vz] = vertices[i];
        *vertexDataPointer++ = vx;
        *vertexDataPointer++ = vy;
        *vertexDataPointer++ = vz;
        if (_hasNormals) {
            const auto &[nx, ny, nz] = normals[i];
            *vertexDataPointer++ = nx;
            *vertexDataPointer++ = ny;
            *vertexDataPointer++ = nz;
        }
        if (_hasTextureCoords) {
            const auto &[u, v] = textureCoords[i];
            *vertexDataPointer++ = u;
            *vertexDataPointer++ = v;
        }
    }
    setVertexData(vertexData);
}

References _hasNormals, and _hasTextureCoords.

Referenced by setMesh().

Here is the caller graph for this function:

Member Data Documentation

_hasNormals

bool model_viewer::geometry::ObjGeometry::_hasNormals = false

private

Whether the geometry contains normals.

Referenced by configureVertexLayout(), setMesh(), and setModelData().

_hasTextureCoords

bool model_viewer::geometry::ObjGeometry::_hasTextureCoords = false

private

Whether the geometry contains texture coordinates.

Referenced by configureVertexLayout(), setMesh(), and setModelData().

---

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

• /github/workspace/include/Geometry/ObjGeometry.hpp
• /github/workspace/src/Geometry/ObjGeometry.cpp