Skip to content

Commit

Permalink
FBX: make lookup test less strict. closes #994
Browse files Browse the repository at this point in the history
  • Loading branch information
@kimkulling
kimkulling committed Sep 28, 2016
1 parent c81767b commit 9f7e346
Show file tree
Hide file tree
Showing 2 changed files with 86 additions and 86 deletions.
142 changes: 71 additions & 71 deletions code/FBXMeshGeometry.cpp
View file
Original file line number Diff line number Diff line change
Expand Up @@ -117,12 +117,12 @@ MeshGeometry::MeshGeometry(uint64_t id, const Element& element, const std::strin
return;
}

vertices.reserve(tempFaces.size());
faces.reserve(tempFaces.size() / 3);
m_vertices.reserve(tempFaces.size());
m_faces.reserve(tempFaces.size() / 3);

mapping_offsets.resize(tempVerts.size());
mapping_counts.resize(tempVerts.size(),0);
mappings.resize(tempFaces.size());
m_mapping_offsets.resize(tempVerts.size());
m_mapping_counts.resize(tempVerts.size(),0);
m_mappings.resize(tempFaces.size());

const size_t vertex_count = tempVerts.size();

Expand All @@ -135,29 +135,29 @@ MeshGeometry::MeshGeometry(uint64_t id, const Element& element, const std::strin
DOMError("polygon vertex index out of range",&PolygonVertexIndex);
}

vertices.push_back(tempVerts[absi]);
m_vertices.push_back(tempVerts[absi]);
++count;

++mapping_counts[absi];
++m_mapping_counts[absi];

if (index < 0) {
faces.push_back(count);
m_faces.push_back(count);
count = 0;
}
}

unsigned int cursor = 0;
for (size_t i = 0, e = tempVerts.size(); i < e; ++i) {
mapping_offsets[i] = cursor;
cursor += mapping_counts[i];
m_mapping_offsets[i] = cursor;
cursor += m_mapping_counts[i];

mapping_counts[i] = 0;
m_mapping_counts[i] = 0;
}

cursor = 0;
for(int index : tempFaces) {
const int absi = index < 0 ? (-index - 1) : index;
mappings[mapping_offsets[absi] + mapping_counts[absi]++] = cursor++;
m_mappings[m_mapping_offsets[absi] + m_mapping_counts[absi]++] = cursor++;
}

// if settings.readAllLayers is true:
Expand Down Expand Up @@ -191,84 +191,84 @@ MeshGeometry::~MeshGeometry()

// ------------------------------------------------------------------------------------------------
const std::vector<aiVector3D>& MeshGeometry::GetVertices() const {
return vertices;
return m_vertices;
}

// ------------------------------------------------------------------------------------------------
const std::vector<aiVector3D>& MeshGeometry::GetNormals() const {
return normals;
return m_normals;
}

// ------------------------------------------------------------------------------------------------
const std::vector<aiVector3D>& MeshGeometry::GetTangents() const {
return tangents;
return m_tangents;
}

// ------------------------------------------------------------------------------------------------
const std::vector<aiVector3D>& MeshGeometry::GetBinormals() const {
return binormals;
return m_binormals;
}

// ------------------------------------------------------------------------------------------------
const std::vector<unsigned int>& MeshGeometry::GetFaceIndexCounts() const {
return faces;
return m_faces;
}

// ------------------------------------------------------------------------------------------------
const std::vector<aiVector2D>& MeshGeometry::GetTextureCoords( unsigned int index ) const {
static const std::vector<aiVector2D> empty;
return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? empty : uvs[ index ];
return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? empty : m_uvs[ index ];
}

std::string MeshGeometry::GetTextureCoordChannelName( unsigned int index ) const {
return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? "" : uvNames[ index ];
return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? "" : m_uvNames[ index ];
}

const std::vector<aiColor4D>& MeshGeometry::GetVertexColors( unsigned int index ) const {
static const std::vector<aiColor4D> empty;
return index >= AI_MAX_NUMBER_OF_COLOR_SETS ? empty : colors[ index ];
return index >= AI_MAX_NUMBER_OF_COLOR_SETS ? empty : m_colors[ index ];
}

const MatIndexArray& MeshGeometry::GetMaterialIndices() const {
return materials;
return m_materials;
}

// ------------------------------------------------------------------------------------------------
const unsigned int* MeshGeometry::ToOutputVertexIndex( unsigned int in_index, unsigned int& count ) const {
if ( in_index >= mapping_counts.size() ) {
if ( in_index >= m_mapping_counts.size() ) {
return NULL;
}

ai_assert( mapping_counts.size() == mapping_offsets.size() );
count = mapping_counts[ in_index ];
ai_assert( m_mapping_counts.size() == m_mapping_offsets.size() );
count = m_mapping_counts[ in_index ];

ai_assert( count != 0 );
ai_assert( mapping_offsets[ in_index ] + count <= mappings.size() );
// ai_assert( count != 0 );
ai_assert( m_mapping_offsets[ in_index ] + count <= m_mappings.size() );

return &mappings[ mapping_offsets[ in_index ] ];
return &m_mappings[ m_mapping_offsets[ in_index ] ];
}

// ------------------------------------------------------------------------------------------------
unsigned int MeshGeometry::FaceForVertexIndex( unsigned int in_index ) const {
ai_assert( in_index < vertices.size() );
ai_assert( in_index < m_vertices.size() );

// in the current conversion pattern this will only be needed if
// weights are present, so no need to always pre-compute this table
if ( facesVertexStartIndices.empty() ) {
facesVertexStartIndices.resize( faces.size() + 1, 0 );
if ( m_facesVertexStartIndices.empty() ) {
m_facesVertexStartIndices.resize( m_faces.size() + 1, 0 );

std::partial_sum( faces.begin(), faces.end(), facesVertexStartIndices.begin() + 1 );
facesVertexStartIndices.pop_back();
std::partial_sum( m_faces.begin(), m_faces.end(), m_facesVertexStartIndices.begin() + 1 );
m_facesVertexStartIndices.pop_back();
}

ai_assert( facesVertexStartIndices.size() == faces.size() );
ai_assert( m_facesVertexStartIndices.size() == m_faces.size() );
const std::vector<unsigned int>::iterator it = std::upper_bound(
facesVertexStartIndices.begin(),
facesVertexStartIndices.end(),
m_facesVertexStartIndices.begin(),
m_facesVertexStartIndices.end(),
in_index
);

return static_cast< unsigned int >( std::distance( facesVertexStartIndices.begin(), it - 1 ) );
return static_cast< unsigned int >( std::distance( m_facesVertexStartIndices.begin(), it - 1 ) );
}

// ------------------------------------------------------------------------------------------------
Expand Down Expand Up @@ -327,18 +327,18 @@ void MeshGeometry::ReadVertexData(const std::string& type, int index, const Scop
}

const Element* Name = source["Name"];
uvNames[index] = "";
m_uvNames[index] = "";
if(Name) {
uvNames[index] = ParseTokenAsString(GetRequiredToken(*Name,0));
m_uvNames[index] = ParseTokenAsString(GetRequiredToken(*Name,0));
}

ReadVertexDataUV(uvs[index],source,
ReadVertexDataUV(m_uvs[index],source,
MappingInformationType,
ReferenceInformationType
);
}
else if (type == "LayerElementMaterial") {
if (materials.size() > 0) {
if (m_materials.size() > 0) {
FBXImporter::LogError("ignoring additional material layer");
return;
}
Expand All @@ -362,37 +362,37 @@ void MeshGeometry::ReadVertexData(const std::string& type, int index, const Scop
return;
}

std::swap(temp_materials, materials);
std::swap(temp_materials, m_materials);
}
else if (type == "LayerElementNormal") {
if (normals.size() > 0) {
if (m_normals.size() > 0) {
FBXImporter::LogError("ignoring additional normal layer");
return;
}

ReadVertexDataNormals(normals,source,
ReadVertexDataNormals(m_normals,source,
MappingInformationType,
ReferenceInformationType
);
}
else if (type == "LayerElementTangent") {
if (tangents.size() > 0) {
if (m_tangents.size() > 0) {
FBXImporter::LogError("ignoring additional tangent layer");
return;
}

ReadVertexDataTangents(tangents,source,
ReadVertexDataTangents(m_tangents,source,
MappingInformationType,
ReferenceInformationType
);
}
else if (type == "LayerElementBinormal") {
if (binormals.size() > 0) {
if (m_binormals.size() > 0) {
FBXImporter::LogError("ignoring additional binormal layer");
return;
}

ReadVertexDataBinormals(binormals,source,
ReadVertexDataBinormals(m_binormals,source,
MappingInformationType,
ReferenceInformationType
);
Expand All @@ -404,7 +404,7 @@ void MeshGeometry::ReadVertexData(const std::string& type, int index, const Scop
return;
}

ReadVertexDataColors(colors[index],source,
ReadVertexDataColors(m_colors[index],source,
MappingInformationType,
ReferenceInformationType
);
Expand Down Expand Up @@ -515,10 +515,10 @@ void MeshGeometry::ReadVertexDataNormals(std::vector<aiVector3D>& normals_out, c
ResolveVertexDataArray(normals_out,source,MappingInformationType,ReferenceInformationType,
"Normals",
"NormalsIndex",
vertices.size(),
mapping_counts,
mapping_offsets,
mappings);
m_vertices.size(),
m_mapping_counts,
m_mapping_offsets,
m_mappings);
}


Expand All @@ -530,10 +530,10 @@ void MeshGeometry::ReadVertexDataUV(std::vector<aiVector2D>& uv_out, const Scope
ResolveVertexDataArray(uv_out,source,MappingInformationType,ReferenceInformationType,
"UV",
"UVIndex",
vertices.size(),
mapping_counts,
mapping_offsets,
mappings);
m_vertices.size(),
m_mapping_counts,
m_mapping_offsets,
m_mappings);
}


Expand All @@ -545,10 +545,10 @@ void MeshGeometry::ReadVertexDataColors(std::vector<aiColor4D>& colors_out, cons
ResolveVertexDataArray(colors_out,source,MappingInformationType,ReferenceInformationType,
"Colors",
"ColorIndex",
vertices.size(),
mapping_counts,
mapping_offsets,
mappings);
m_vertices.size(),
m_mapping_counts,
m_mapping_offsets,
m_mappings);
}

// ------------------------------------------------------------------------------------------------
Expand All @@ -564,10 +564,10 @@ void MeshGeometry::ReadVertexDataTangents(std::vector<aiVector3D>& tangents_out,
ResolveVertexDataArray(tangents_out,source,MappingInformationType,ReferenceInformationType,
str,
strIdx,
vertices.size(),
mapping_counts,
mapping_offsets,
mappings);
m_vertices.size(),
m_mapping_counts,
m_mapping_offsets,
m_mappings);
}

// ------------------------------------------------------------------------------------------------
Expand All @@ -583,10 +583,10 @@ void MeshGeometry::ReadVertexDataBinormals(std::vector<aiVector3D>& binormals_ou
ResolveVertexDataArray(binormals_out,source,MappingInformationType,ReferenceInformationType,
str,
strIdx,
vertices.size(),
mapping_counts,
mapping_offsets,
mappings);
m_vertices.size(),
m_mapping_counts,
m_mapping_offsets,
m_mappings);
}


Expand All @@ -595,7 +595,7 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
const std::string& MappingInformationType,
const std::string& ReferenceInformationType)
{
const size_t face_count = faces.size();
const size_t face_count = m_faces.size();
ai_assert(face_count);

// materials are handled separately. First of all, they are assigned per-face
Expand All @@ -614,10 +614,10 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector<int>& materials_out, cons
materials_out.clear();
}

materials.assign(vertices.size(),materials_out[0]);
m_materials.assign(m_vertices.size(),materials_out[0]);
}
else if (MappingInformationType == "ByPolygon" && ReferenceInformationType == "IndexToDirect") {
materials.resize(face_count);
m_materials.resize(face_count);

if(materials_out.size() != face_count) {
FBXImporter::LogError(Formatter::format("length of input data unexpected for ByPolygon mapping: ")
Expand Down
30 changes: 15 additions & 15 deletions code/FBXMeshGeometry.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -156,21 +156,21 @@ class MeshGeometry : public Geometry

private:
// cached data arrays
MatIndexArray materials;
std::vector<aiVector3D> vertices;
std::vector<unsigned int> faces;
mutable std::vector<unsigned int> facesVertexStartIndices;
std::vector<aiVector3D> tangents;
std::vector<aiVector3D> binormals;
std::vector<aiVector3D> normals;

std::string uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
std::vector<aiVector2D> uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
std::vector<aiColor4D> colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];

std::vector<unsigned int> mapping_counts;
std::vector<unsigned int> mapping_offsets;
std::vector<unsigned int> mappings;
MatIndexArray m_materials;
std::vector<aiVector3D> m_vertices;
std::vector<unsigned int> m_faces;
mutable std::vector<unsigned int> m_facesVertexStartIndices;
std::vector<aiVector3D> m_tangents;
std::vector<aiVector3D> m_binormals;
std::vector<aiVector3D> m_normals;

std::string m_uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
std::vector<aiVector2D> m_uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
std::vector<aiColor4D> m_colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];

std::vector<unsigned int> m_mapping_counts;
std::vector<unsigned int> m_mapping_offsets;
std::vector<unsigned int> m_mappings;
};

}
Expand Down

0 comments on commit 9f7e346

Please sign in to comment.