sid
/
NazaraEngine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Utility/OBJParser: Optimized loading 

Former-commit-id: b21724d63e15bda0a9c5b8a4c9941b4b606b3525 [formerly 375bc4032044631fd2a1f51f3407b71c2c582944]
Former-commit-id: aa71b4fcfacd25991da8c3b69fbc7ac9c0039ad6
This commit is contained in:
Lynix 2016-07-07 09:00:35 +02:00
parent 964b4cf730
commit a92a3a2901
4 changed files with 222 additions and 191 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

50
include/Nazara/Utility/Formats/OBJParser.hpp
View File

@ -29,51 +29,59 @@ namespace Nz
struct Face
{
std::vector<FaceVertex> vertices;
std::size_t firstVertex;
std::size_t vertexCount;
};
struct Mesh
{
std::vector<Face> faces;
std::vector<FaceVertex> vertices;
String name;
unsigned int material;
std::size_t material;
};
OBJParser(Stream& stream$);
~OBJParser();
OBJParser() = default;
~OBJParser() = default;
const String* GetMaterials() const;
unsigned int GetMaterialCount() const;
const Mesh* GetMeshes() const;
unsigned int GetMeshCount() const;
const String& GetMtlLib() const;
const Vector3f* GetNormals() const;
unsigned int GetNormalCount() const;
const Vector4f* GetPositions() const;
unsigned int GetPositionCount() const;
const Vector3f* GetTexCoords() const;
unsigned int GetTexCoordCount() const;
inline const String* GetMaterials() const;
inline unsigned int GetMaterialCount() const;
inline const Mesh* GetMeshes() const;
inline unsigned int GetMeshCount() const;
inline const String& GetMtlLib() const;
inline const Vector3f* GetNormals() const;
inline unsigned int GetNormalCount() const;
inline const Vector4f* GetPositions() const;
inline unsigned int GetPositionCount() const;
inline const Vector3f* GetTexCoords() const;
inline unsigned int GetTexCoordCount() const;
bool Parse(std::size_t reservedVertexCount = 100);
bool Parse(Stream& stream, std::size_t reservedVertexCount = 100);
private:
bool Advance(bool required = true);
void Error(const String& message);
void Warning(const String& message);
void UnrecognizedLine(bool error = false);
template<typename T> void Emit(const T& text) const;
inline void EmitLine() const;
template<typename T> void EmitLine(const T& line) const;
inline void Error(const String& message);
inline void Flush() const;
inline void Warning(const String& message);
inline void UnrecognizedLine(bool error = false);
std::vector<Mesh> m_meshes;
std::vector<String> m_materials;
std::vector<Vector3f> m_normals;
std::vector<Vector4f> m_positions;
std::vector<Vector3f> m_texCoords;
Stream& m_stream;
mutable Stream* m_currentStream;
String m_currentLine;
String m_mtlLib;
mutable StringStream m_outputStream;
bool m_keepLastLine;
unsigned int m_lineCount;
unsigned int m_streamFlags;
};
}
#include <Nazara/Utility/Formats/OBJParser.inl>
#endif // NAZARA_FORMATS_OBJPARSER_HPP

88
include/Nazara/Utility/Formats/OBJParser.inl Normal file
View File

@ -0,0 +1,88 @@
// Copyright (C) 2016 Jérôme Leclercq
// This file is part of the "Nazara Engine - Utility module"
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Utility/Formats/OBJParser.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Utility/Debug.hpp>
namespace Nz
{
inline const String* OBJParser::GetMaterials() const
{
return m_materials.data();
}
inline unsigned int OBJParser::GetMaterialCount() const
{
return m_materials.size();
}
inline const OBJParser::Mesh* OBJParser::GetMeshes() const
{
return m_meshes.data();
}
inline unsigned int OBJParser::GetMeshCount() const
{
return m_meshes.size();
}
inline const String& OBJParser::GetMtlLib() const
{
return m_mtlLib;
}
inline const Vector3f* OBJParser::GetNormals() const
{
return m_normals.data();
}
inline unsigned int OBJParser::GetNormalCount() const
{
return m_normals.size();
}
inline const Vector4f* OBJParser::GetPositions() const
{
return m_positions.data();
}
inline unsigned int OBJParser::GetPositionCount() const
{
return m_positions.size();
}
inline const Vector3f* OBJParser::GetTexCoords() const
{
return m_texCoords.data();
}
inline unsigned int OBJParser::GetTexCoordCount() const
{
return m_texCoords.size();
}
inline void OBJParser::Error(const String& message)
{
NazaraError(message + " at line #" + String::Number(m_lineCount));
}
inline void OBJParser::Warning(const String& message)
{
NazaraWarning(message + " at line #" + String::Number(m_lineCount));
}
inline void OBJParser::UnrecognizedLine(bool error)
{
String message = "Unrecognized \"" + m_currentLine + '"';
if (error)
Error(message);
else
Warning(message);
}
}
#include <Nazara/Utility/DebugOff.hpp>

22
src/Nazara/Utility/Formats/OBJLoader.cpp
View File

@ -123,8 +123,8 @@ namespace Nz
if (!parameters.custom.GetIntegerParameter("NativeOBJLoader_VertexCount", &reservedVertexCount))
reservedVertexCount = 100;
OBJParser parser(stream);
if (!parser.Parse(reservedVertexCount))
OBJParser parser;
if (!parser.Parse(stream, reservedVertexCount))
{
NazaraError("OBJ parser failed");
return false;
@ -177,23 +177,24 @@ namespace Nz
{
bool operator()(const OBJParser::FaceVertex& lhs, const OBJParser::FaceVertex& rhs) const
{
return lhs.normal == rhs.normal &&
return lhs.normal == rhs.normal &&
lhs.position == rhs.position &&
lhs.texCoord == rhs.texCoord;
}
};
std::unordered_map<OBJParser::FaceVertex, unsigned int, FaceVertexHasher, FaceVertexComparator> vertices;
vertices.reserve(meshes[i].vertices.size());
unsigned int vertexCount = 0;
for (unsigned int j = 0; j < faceCount; ++j)
{
unsigned int faceVertexCount = meshes[i].faces[j].vertices.size();
unsigned int faceVertexCount = meshes[i].faces[j].vertexCount;
faceIndices.resize(faceVertexCount);
for (unsigned int k = 0; k < faceVertexCount; ++k)
{
const OBJParser::FaceVertex& vertex = meshes[i].faces[j].vertices[k];
const OBJParser::FaceVertex& vertex = meshes[i].vertices[meshes[i].faces[j].firstVertex + k];
auto it = vertices.find(vertex);
if (it == vertices.end())
@ -202,6 +203,7 @@ namespace Nz
faceIndices[k] = it->second;
}
// Triangulation
for (unsigned int k = 1; k < faceVertexCount-1; ++k)
{
indices.push_back(faceIndices[0]);
@ -233,17 +235,17 @@ namespace Nz
MeshVertex& vertex = meshVertices[index];
const Vector4f& vec = positions[vertexIndices.position];
const Vector4f& vec = positions[vertexIndices.position-1];
vertex.position = Vector3f(parameters.matrix * vec);
if (vertexIndices.normal >= 0)
vertex.normal = normals[vertexIndices.normal];
if (vertexIndices.normal > 0)
vertex.normal = normals[vertexIndices.normal-1];
else
hasNormals = false;
if (vertexIndices.texCoord >= 0)
if (vertexIndices.texCoord > 0)
{
const Vector3f& uvw = texCoords[vertexIndices.texCoord];
const Vector3f& uvw = texCoords[vertexIndices.texCoord-1];
vertex.uv.Set(uvw.x, (parameters.flipUVs) ? 1.f - uvw.y : uvw.y); // Inversion des UVs si demandé
}
else

253
src/Nazara/Utility/Formats/OBJParser.cpp
View File

@ -3,7 +3,7 @@
// For conditions of distribution and use, see copyright notice in Config.hpp
#include <Nazara/Utility/Formats/OBJParser.hpp>
#include <Nazara/Core/Error.hpp>
#include <Nazara/Core/CallOnExit.hpp>
#include <Nazara/Core/Log.hpp>
#include <Nazara/Utility/Config.hpp>
#include <cctype>
@ -13,77 +13,22 @@
namespace Nz
{
OBJParser::OBJParser(Stream& stream) :
m_stream(stream),
m_streamFlags(stream.GetStreamOptions()) //< Saves stream flags
bool OBJParser::Parse(Nz::Stream& stream, std::size_t reservedVertexCount)
{
m_stream.EnableTextMode(true);
}
m_currentStream = &stream;
OBJParser::~OBJParser()
{
// Reset stream flags
if ((m_streamFlags & StreamOption_Text) == 0)
m_stream.EnableTextMode(false);
}
// Force stream in text mode, reset it at the end
Nz::CallOnExit resetTextMode;
if ((stream.GetStreamOptions() & StreamOption_Text) == 0)
{
stream.EnableTextMode(true);
const String* OBJParser::GetMaterials() const
{
return m_materials.data();
}
resetTextMode.Reset([&stream] ()
{
stream.EnableTextMode(false);
});
}
unsigned int OBJParser::GetMaterialCount() const
{
return m_materials.size();
}
const OBJParser::Mesh* OBJParser::GetMeshes() const
{
return m_meshes.data();
}
unsigned int OBJParser::GetMeshCount() const
{
return m_meshes.size();
}
const String& OBJParser::GetMtlLib() const
{
return m_mtlLib;
}
const Vector3f* OBJParser::GetNormals() const
{
return m_normals.data();
}
unsigned int OBJParser::GetNormalCount() const
{
return m_normals.size();
}
const Vector4f* OBJParser::GetPositions() const
{
return m_positions.data();
}
unsigned int OBJParser::GetPositionCount() const
{
return m_positions.size();
}
const Vector3f* OBJParser::GetTexCoords() const
{
return m_texCoords.data();
}
unsigned int OBJParser::GetTexCoordCount() const
{
return m_texCoords.size();
}
bool OBJParser::Parse(std::size_t reservedVertexCount)
{
String matName, meshName;
matName = meshName = "default";
m_keepLastLine = false;
@ -100,32 +45,56 @@ namespace Nz
m_positions.reserve(reservedVertexCount);
m_texCoords.reserve(reservedVertexCount);
// On va regrouper les meshs par nom et par matériau
using FaceVec = std::vector<Face>;
using MatPair = std::pair<FaceVec, unsigned int>;
std::unordered_map<String, std::unordered_map<String, MatPair>> meshes;
// Sort meshes by material and group
using MatPair = std::pair<Mesh, unsigned int>;
std::unordered_map<String, std::unordered_map<String, MatPair>> meshesByName;
unsigned int matIndex = 0;
auto GetMaterial = [&meshes, &matIndex] (const String& mesh, const String& material) -> FaceVec*
std::size_t faceReserve = 0;
std::size_t vertexReserve = 0;
unsigned int matCount = 0;
auto GetMaterial = [&] (const String& meshName, const String& matName) -> Mesh*
{
auto& map = meshes[mesh];
auto it = map.find(material);
auto& map = meshesByName[meshName];
auto it = map.find(matName);
if (it == map.end())
it = map.insert(std::make_pair(material, MatPair(FaceVec(), matIndex++))).first;
it = map.insert(std::make_pair(matName, MatPair(Mesh(), matCount++))).first;
Mesh& mesh = it->second.first;
mesh.faces.reserve(faceReserve);
mesh.vertices.reserve(vertexReserve);
faceReserve = 0;
vertexReserve = 0;
return &(it->second.first);
};
// On prépare le mesh par défaut
FaceVec* currentMesh = nullptr;
Mesh* currentMesh = nullptr;
while (Advance(false))
{
switch (std::tolower(m_currentLine[0]))
{
case 'f': // Une face
case '#': //< Comment
// Some softwares write comments to gives the number of vertex/faces an importer can expect
std::size_t data;
if (std::sscanf(m_currentLine.GetConstBuffer(), "# position count: %zu", &data) == 1)
m_positions.reserve(data);
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# normal count: %zu", &data) == 1)
m_normals.reserve(data);
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# texcoords count: %zu", &data) == 1)
m_texCoords.reserve(data);
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# face count: %zu", &data) == 1)
faceReserve = data;
else if (std::sscanf(m_currentLine.GetConstBuffer(), "# vertex count: %zu", &data) == 1)
vertexReserve = data;
break;
case 'f': //< Face
{
if (m_currentLine.GetSize() < 7) // Le minimum syndical pour définir une face de trois sommets (f 1 2 3)
if (m_currentLine.GetSize() < 7) // Since we only treat triangles, this is the minimum length of a face line (f 1 2 3)
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
UnrecognizedLine();
@ -142,17 +111,23 @@ namespace Nz
break;
}
if (!currentMesh)
currentMesh = GetMaterial(meshName, matName);
Face face;
face.vertices.resize(vertexCount);
face.firstVertex = currentMesh->vertices.size();
face.vertexCount = vertexCount;
currentMesh->vertices.resize(face.firstVertex + vertexCount, FaceVertex{0, 0, 0});
bool error = false;
unsigned int pos = 2;
for (unsigned int i = 0; i < vertexCount; ++i)
{
int offset;
int& n = face.vertices[i].normal;
int& p = face.vertices[i].position;
int& t = face.vertices[i].texCoord;
int& n = currentMesh->vertices[face.firstVertex + i].normal;
int& p = currentMesh->vertices[face.firstVertex + i].position;
int& t = currentMesh->vertices[face.firstVertex + i].texCoord;
if (std::sscanf(&m_currentLine[pos], "%d/%d/%d%n", &p, &t, &n, &offset) != 3)
{
@ -168,22 +143,13 @@ namespace Nz
error = true;
break;
}
else
{
n = 0;
t = 0;
}
}
else
n = 0;
}
else
t = 0;
}
if (p < 0)
{
p += m_positions.size();
p += m_positions.size() - 1;
if (p < 0)
{
Error("Vertex index out of range (" + String::Number(p) + " < 0");
@ -191,48 +157,42 @@ namespace Nz
break;
}
}
else
p--;
if (n < 0)
{
n += m_normals.size();
n += m_normals.size() - 1;
if (n < 0)
{
Error("Vertex index out of range (" + String::Number(n) + " < 0");
Error("Normal index out of range (" + String::Number(n) + " < 0");
error = true;
break;
}
}
else
n--;
if (t < 0)
{
t += m_texCoords.size();
t += m_texCoords.size() - 1;
if (t < 0)
{
Error("Vertex index out of range (" + String::Number(t) + " < 0");
Error("Texture coordinates index out of range (" + String::Number(t) + " < 0");
error = true;
break;
}
}
else
t--;
if (static_cast<unsigned int>(p) >= m_positions.size())
if (static_cast<std::size_t>(p) > m_positions.size())
{
Error("Vertex index out of range (" + String::Number(p) + " >= " + String::Number(m_positions.size()) + ')');
error = true;
break;
}
else if (n >= 0 && static_cast<unsigned int>(n) >= m_normals.size())
else if (n != 0 && static_cast<std::size_t>(n) > m_normals.size())
{
Error("Normal index out of range (" + String::Number(n) + " >= " + String::Number(m_normals.size()) + ')');
error = true;
break;
}
else if (t >= 0 && static_cast<unsigned int>(t) >= m_texCoords.size())
else if (t != 0 && static_cast<std::size_t>(t) > m_texCoords.size())
{
Error("TexCoord index out of range (" + String::Number(t) + " >= " + String::Number(m_texCoords.size()) + ')');
error = true;
@ -243,17 +203,14 @@ namespace Nz
}
if (!error)
{
if (!currentMesh)
currentMesh = GetMaterial(meshName, matName);
currentMesh->push_back(std::move(face));
}
currentMesh->faces.push_back(std::move(face));
else
currentMesh->vertices.resize(face.firstVertex); //< Remove vertices
break;
}
case 'm':
case 'm': //< MTLLib
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
if (m_currentLine.GetWord(0).ToLower() != "mtllib")
UnrecognizedLine();
@ -262,8 +219,8 @@ namespace Nz
m_mtlLib = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
break;
case 'g':
case 'o':
case 'g': //< Group (inside a mesh)
case 'o': //< Object (defines a mesh)
{
if (m_currentLine.GetSize() <= 2 || m_currentLine[1] != ' ')
{
@ -283,12 +240,12 @@ namespace Nz
}
meshName = objectName;
currentMesh = GetMaterial(meshName, matName);
currentMesh = nullptr;
break;
}
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
case 's':
case 's': //< Smooth
if (m_currentLine.GetSize() <= 2 || m_currentLine[1] == ' ')
{
String param = m_currentLine.SubString(2);
@ -298,15 +255,16 @@ namespace Nz
else
UnrecognizedLine();
break;
#endif
#endif
case 'u':
case 'u': //< Usemtl
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
if (m_currentLine.GetWord(0) != "usemtl")
UnrecognizedLine();
#endif
matName = m_currentLine.SubString(m_currentLine.GetWordPosition(1));
currentMesh = nullptr;
if (matName.IsEmpty())
{
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
@ -314,18 +272,16 @@ namespace Nz
#endif
break;
}
currentMesh = GetMaterial(meshName, matName);
break;
case 'v':
case 'v': //< Position/Normal/Texcoords
{
String word = m_currentLine.GetWord(0).ToLower();
if (word == 'v')
{
Vector4f vertex(Vector3f::Zero(), 1.f);
unsigned int paramCount = std::sscanf(&m_currentLine[2], "%f %f %f %f", &vertex.x, &vertex.y, &vertex.z, &vertex.w);
if (paramCount >= 3)
if (paramCount >= 1)
m_positions.push_back(vertex);
#if NAZARA_UTILITY_STRICT_RESOURCE_PARSING
else
@ -371,26 +327,24 @@ namespace Nz
}
std::unordered_map<String, unsigned int> materials;
m_materials.resize(matIndex);
m_materials.resize(matCount);
for (auto& meshIt : meshes)
for (auto& meshPair : meshesByName)
{
for (auto& matIt : meshIt.second)
for (auto& matPair : meshPair.second)
{
auto& faceVec = matIt.second.first;
unsigned int index = matIt.second.second;
if (!faceVec.empty())
Mesh& mesh = matPair.second.first;
unsigned int index = matPair.second.second;
if (!mesh.faces.empty())
{
Mesh mesh;
mesh.faces = std::move(faceVec);
mesh.name = meshIt.first;
mesh.name = meshPair.first;
auto it = materials.find(matIt.first);
auto it = materials.find(matPair.first);
if (it == materials.end())
{
mesh.material = index;
materials[matIt.first] = index;
m_materials[index] = matIt.first;
materials[matPair.first] = index;
m_materials[index] = matPair.first;
}
else
mesh.material = it->second;
@ -415,7 +369,7 @@ namespace Nz
{
do
{
if (m_stream.EndOfStream())
if (m_currentStream->EndOfStream())
{
if (required)
Error("Incomplete OBJ file");
@ -425,9 +379,8 @@ namespace Nz
m_lineCount++;
m_currentLine = m_stream.ReadLine();
m_currentLine = m_currentLine.SubStringTo("#"); // On ignore les commentaires
m_currentLine.Simplify(); // Pour un traitement plus simple
m_currentLine = m_currentStream->ReadLine();
m_currentLine.Simplify(); // Simplify lines (convert multiple blanks into a single space and trims)
}
while (m_currentLine.IsEmpty());
}
@ -436,24 +389,4 @@ namespace Nz
return true;
}
void OBJParser::Error(const String& message)
{
NazaraError(message + " at line #" + String::Number(m_lineCount));
}
void OBJParser::Warning(const String& message)
{
NazaraWarning(message + " at line #" + String::Number(m_lineCount));
}
void OBJParser::UnrecognizedLine(bool error)
{
String message = "Unrecognized \"" + m_currentLine + '"';
if (error)
Error(message);
else
Warning(message);
}
}