// Copyright (C) 2017 The Qt Company Ltd and/or its subsidiary(-ies). // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only #include "objgeometryloader.h" #include #include #include #include QT_BEGIN_NAMESPACE namespace Qt3DRender { Q_LOGGING_CATEGORY(ObjGeometryLoaderLog, "Qt3D.ObjGeometryLoader", QtWarningMsg) static void addFaceVertex(const FaceIndices &faceIndices, QList &faceIndexVector, QHash &faceIndexMap); inline uint qHash(const FaceIndices &faceIndices) { return faceIndices.positionIndex + 10 * faceIndices.texCoordIndex + 100 * faceIndices.normalIndex; } bool ObjGeometryLoader::doLoad(QIODevice *ioDev, const QString &subMesh) { // Parse faces taking into account each vertex in a face can index different indices // for the positions, normals and texture coords; // Generate unique vertices (in OpenGL parlance) and output to points, texCoords, // normals and calculate mapping from faces to unique indices QList positions; QList normals; QList texCoords; QHash faceIndexMap; QList faceIndexVector; bool skipping = false; int positionsOffset = 0; int normalsOffset = 0; int texCoordsOffset = 0; QRegularExpression subMeshMatch(subMesh); if (!subMeshMatch.isValid()) subMeshMatch.setPattern(QLatin1String("^(") + subMesh + QLatin1String(")$")); Q_ASSERT(subMeshMatch.isValid()); char lineBuffer[1024]; const char *line; QByteArray longLine; while (!ioDev->atEnd()) { // try to read into lineBuffer first, if the line fits (common case) we can do this without expensive allocations // if not, fall back to dynamically allocated QByteArrays auto lineSize = ioDev->readLine(lineBuffer, sizeof(lineBuffer)); if (lineSize == sizeof(lineBuffer) - 1 && lineBuffer[lineSize - 1] != '\n') { longLine = QByteArray(lineBuffer, lineSize); longLine += ioDev->readLine(); line = longLine.constData(); lineSize = longLine.size(); } else { line = lineBuffer; } if (lineSize > 0 && line[0] != '#') { if (line[lineSize - 1] == '\n') --lineSize; // chop newline if (lineSize <= 0) continue; if (line[lineSize - 1] == '\r') --lineSize; // chop newline also for CRLF format if (lineSize <= 0) continue; while (lineSize > 0 && (line[lineSize - 1] == ' ' || line[lineSize - 1] == '\t')) { --lineSize; // chop trailing spaces } if (lineSize <= 0) continue; const ByteArraySplitter tokens(line, line + lineSize, ' ', Qt::SkipEmptyParts); if (qstrncmp(tokens.charPtrAt(0), "v ", 2) == 0) { if (tokens.size() < 4) { qCWarning(ObjGeometryLoaderLog) << "Unsupported number of components in vertex"; } else { if (!skipping) { const float x = tokens.floatAt(1); const float y = tokens.floatAt(2); const float z = tokens.floatAt(3); positions.append(QVector3D(x, y, z)); } else { positionsOffset++; } } } else if (m_loadTextureCoords && qstrncmp(tokens.charPtrAt(0), "vt ", 3) == 0) { if (tokens.size() < 3) { qCWarning(ObjGeometryLoaderLog) << "Unsupported number of components in texture coordinate"; } else { if (!skipping) { // Process texture coordinate const float s = tokens.floatAt(1); const float t = tokens.floatAt(2); texCoords.append(QVector2D(s, t)); } else { ++texCoordsOffset; } } } else if (qstrncmp(tokens.charPtrAt(0), "vn ", 3) == 0) { if (tokens.size() < 4) { qCWarning(ObjGeometryLoaderLog) << "Unsupported number of components in vertex normal"; } else { if (!skipping) { const float x = tokens.floatAt(1); const float y = tokens.floatAt(2); const float z = tokens.floatAt(3); normals.append(QVector3D(x, y, z)); } else { ++normalsOffset; } } } else if (!skipping && tokens.size() >= 4 && qstrncmp(tokens.charPtrAt(0), "f ", 2) == 0) { // Process face int faceVertices = tokens.size() - 1; QVarLengthArray face; // try to avoid allocations in the common case of triangulated data face.reserve(faceVertices); for (int i = 0; i < faceVertices; i++) { FaceIndices faceIndices; const ByteArraySplitter indices = tokens.splitterAt(i + 1, '/', Qt::KeepEmptyParts); switch (indices.size()) { case 3: faceIndices.normalIndex = indices.intAt(2) - 1 - normalsOffset; // fall through Q_FALLTHROUGH(); case 2: faceIndices.texCoordIndex = indices.intAt(1) - 1 - texCoordsOffset; // fall through Q_FALLTHROUGH(); case 1: faceIndices.positionIndex = indices.intAt(0) - 1 - positionsOffset; break; default: qCWarning(ObjGeometryLoaderLog) << "Unsupported number of indices in face element"; } face.append(faceIndices); } // If number of edges in face is greater than 3, // decompose into triangles as a triangle fan. FaceIndices v0 = face[0]; FaceIndices v1 = face[1]; FaceIndices v2 = face[2]; // First face addFaceVertex(v0, faceIndexVector, faceIndexMap); addFaceVertex(v1, faceIndexVector, faceIndexMap); addFaceVertex(v2, faceIndexVector, faceIndexMap); for (int i = 3; i < face.size(); ++i) { v1 = v2; v2 = face[i]; addFaceVertex(v0, faceIndexVector, faceIndexMap); addFaceVertex(v1, faceIndexVector, faceIndexMap); addFaceVertex(v2, faceIndexVector, faceIndexMap); } // end of face } else if (qstrncmp(tokens.charPtrAt(0), "o ", 2) == 0) { if (tokens.size() < 2) { qCWarning(ObjGeometryLoaderLog) << "Missing submesh name"; } else { if (!subMesh.isEmpty() ) { const QString objName = tokens.stringAt(1); QRegularExpressionMatch match = subMeshMatch.match(objName); skipping = !match.hasMatch(); } } } } // empty input line } // while (!ioDev->atEnd()) // Iterate over the faceIndexMap and pull out pos, texCoord and normal data // thereby generating unique vertices of data (by OpenGL definition) const qsizetype vertexCount = faceIndexMap.size(); const bool hasTexCoords = !texCoords.isEmpty(); const bool hasNormals = !normals.isEmpty(); m_points.resize(vertexCount); m_texCoords.clear(); if (hasTexCoords) m_texCoords.resize(vertexCount); m_normals.clear(); if (hasNormals) m_normals.resize(vertexCount); for (auto it = faceIndexMap.cbegin(), endIt = faceIndexMap.cend(); it != endIt; ++it) { const uint positionIndex = it.key().positionIndex; const uint texCoordIndex = it.key().texCoordIndex; const uint normalIndex = it.key().normalIndex; m_points[it.value()] = (positionIndex < uint(positions.size())) ? positions[positionIndex] : QVector3D(); if (hasTexCoords) m_texCoords[it.value()] = (texCoordIndex < uint(texCoords.size())) ? texCoords[texCoordIndex] : QVector2D(); if (hasNormals) m_normals[it.value()] = (normalIndex < uint(normals.size())) ? normals[normalIndex] : QVector3D(); } // Now iterate over the face indices and lookup the unique vertex index const qsizetype indexCount = faceIndexVector.size(); m_indices.clear(); m_indices.reserve(indexCount); for (const FaceIndices &faceIndices : std::as_const(faceIndexVector)) { const unsigned int i = faceIndexMap.value(faceIndices); m_indices.push_back(i); } return true; } static void addFaceVertex(const FaceIndices &faceIndices, QList &faceIndexVector, QHash &faceIndexMap) { if (faceIndices.positionIndex != std::numeric_limits::max()) { faceIndexVector.append(faceIndices); if (!faceIndexMap.contains(faceIndices)) faceIndexMap.insert(faceIndices, faceIndexMap.size()); } else { qCWarning(ObjGeometryLoaderLog) << "Missing position index"; } } } // namespace Qt3DRender QT_END_NAMESPACE