Merge branch 'master' into import_x3d

Readme.md

@@ -15,6 +15,7 @@ Coverity<a href="https://scan.coverity.com/projects/5607">
        src="https://scan.coverity.com/projects/5607/badge.svg"/>
 </a>
 <br>
+Gitter chat: [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
 __[open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities.__
 
 #### Supported file formats ####

code/FBXMeshGeometry.cpp

@@ -117,12 +117,12 @@ MeshGeometry::MeshGeometry(uint64_t id, const Element& element, const std::strin
         return;
     }
 
-    vertices.reserve(tempFaces.size());
+    m_vertices.reserve(tempFaces.size());
-    faces.reserve(tempFaces.size() / 3);
+    m_faces.reserve(tempFaces.size() / 3);
 
-    mapping_offsets.resize(tempVerts.size());
+    m_mapping_offsets.resize(tempVerts.size());
-    mapping_counts.resize(tempVerts.size(),0);
+    m_mapping_counts.resize(tempVerts.size(),0);
-    mappings.resize(tempFaces.size());
+    m_mappings.resize(tempFaces.size());
 
     const size_t vertex_count = tempVerts.size();
 
@@ -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;
+        m_mapping_offsets[i] = cursor;
-        cursor += mapping_counts[i];
+        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:
@@ -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() );
+    ai_assert( m_mapping_counts.size() == m_mapping_offsets.size() );
-    count = mapping_counts[ in_index ];
+    count = m_mapping_counts[ in_index ];
 
-    ai_assert( count != 0 );
+//    ai_assert( count != 0 );
-    ai_assert( mapping_offsets[ in_index ] + count <= mappings.size() );
+    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() ) {
+    if ( m_facesVertexStartIndices.empty() ) {
-        facesVertexStartIndices.resize( faces.size() + 1, 0 );
+        m_facesVertexStartIndices.resize( m_faces.size() + 1, 0 );
 
-        std::partial_sum( faces.begin(), faces.end(), facesVertexStartIndices.begin() + 1 );
+        std::partial_sum( m_faces.begin(), m_faces.end(), m_facesVertexStartIndices.begin() + 1 );
-        facesVertexStartIndices.pop_back();
+        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(),
+        m_facesVertexStartIndices.begin(),
-        facesVertexStartIndices.end(),
+        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 ) );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -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;
         }
@@ -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
         );
@@ -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
         );
@@ -515,10 +515,10 @@ void MeshGeometry::ReadVertexDataNormals(std::vector<aiVector3D>& normals_out, c
     ResolveVertexDataArray(normals_out,source,MappingInformationType,ReferenceInformationType,
         "Normals",
         "NormalsIndex",
-        vertices.size(),
+        m_vertices.size(),
-        mapping_counts,
+        m_mapping_counts,
-        mapping_offsets,
+        m_mapping_offsets,
-        mappings);
+        m_mappings);
 }
 
 
@@ -530,10 +530,10 @@ void MeshGeometry::ReadVertexDataUV(std::vector<aiVector2D>& uv_out, const Scope
     ResolveVertexDataArray(uv_out,source,MappingInformationType,ReferenceInformationType,
         "UV",
         "UVIndex",
-        vertices.size(),
+        m_vertices.size(),
-        mapping_counts,
+        m_mapping_counts,
-        mapping_offsets,
+        m_mapping_offsets,
-        mappings);
+        m_mappings);
 }
 
 
@@ -545,10 +545,10 @@ void MeshGeometry::ReadVertexDataColors(std::vector<aiColor4D>& colors_out, cons
     ResolveVertexDataArray(colors_out,source,MappingInformationType,ReferenceInformationType,
         "Colors",
         "ColorIndex",
-        vertices.size(),
+        m_vertices.size(),
-        mapping_counts,
+        m_mapping_counts,
-        mapping_offsets,
+        m_mapping_offsets,
-        mappings);
+        m_mappings);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -564,10 +564,10 @@ void MeshGeometry::ReadVertexDataTangents(std::vector<aiVector3D>& tangents_out,
     ResolveVertexDataArray(tangents_out,source,MappingInformationType,ReferenceInformationType,
         str,
         strIdx,
-        vertices.size(),
+        m_vertices.size(),
-        mapping_counts,
+        m_mapping_counts,
-        mapping_offsets,
+        m_mapping_offsets,
-        mappings);
+        m_mappings);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -583,10 +583,10 @@ void MeshGeometry::ReadVertexDataBinormals(std::vector<aiVector3D>& binormals_ou
     ResolveVertexDataArray(binormals_out,source,MappingInformationType,ReferenceInformationType,
         str,
         strIdx,
-        vertices.size(),
+        m_vertices.size(),
-        mapping_counts,
+        m_mapping_counts,
-        mapping_offsets,
+        m_mapping_offsets,
-        mappings);
+        m_mappings);
 }
 
 
@@ -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
@@ -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: ")

code/FBXMeshGeometry.h

@@ -156,21 +156,21 @@ private:
 
 private:
     // cached data arrays
-    MatIndexArray materials;
+    MatIndexArray m_materials;
-    std::vector<aiVector3D> vertices;
+    std::vector<aiVector3D> m_vertices;
-    std::vector<unsigned int> faces;
+    std::vector<unsigned int> m_faces;
-    mutable std::vector<unsigned int> facesVertexStartIndices;
+    mutable std::vector<unsigned int> m_facesVertexStartIndices;
-    std::vector<aiVector3D> tangents;
+    std::vector<aiVector3D> m_tangents;
-    std::vector<aiVector3D> binormals;
+    std::vector<aiVector3D> m_binormals;
-    std::vector<aiVector3D> normals;
+    std::vector<aiVector3D> m_normals;
 
-    std::string uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+    std::string m_uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
-    std::vector<aiVector2D> uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+    std::vector<aiVector2D> m_uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
-    std::vector<aiColor4D> colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
+    std::vector<aiColor4D> m_colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
 
-    std::vector<unsigned int> mapping_counts;
+    std::vector<unsigned int> m_mapping_counts;
-    std::vector<unsigned int> mapping_offsets;
+    std::vector<unsigned int> m_mapping_offsets;
-    std::vector<unsigned int> mappings;
+    std::vector<unsigned int> m_mappings;
 };
 
 }

code/glTFAsset.inl

@@ -696,6 +696,7 @@ inline void Material::Read(Value& material, Asset& r)
         ReadMaterialProperty(r, *values, "diffuse", this->diffuse);
         ReadMaterialProperty(r, *values, "specular", this->specular);
 
+        ReadMember(*values, "transparency", transparency);
         ReadMember(*values, "shininess", shininess);
     }
 

code/glTFAssetWriter.inl

@@ -171,6 +171,9 @@ namespace glTF {
             WriteColorOrTex(v, m.specular, "specular", w.mAl);
             WriteColorOrTex(v, m.emission, "emission", w.mAl);
 
+            if (m.transparent)
+                v.AddMember("transparency", m.transparency, w.mAl);
+
             v.AddMember("shininess", m.shininess, w.mAl);
         }
         obj.AddMember("values", v, w.mAl);

code/glTFExporter.cpp

@@ -274,6 +274,8 @@ void glTFExporter::ExportMaterials()
         GetMatColorOrTex(mat, m->specular, AI_MATKEY_COLOR_SPECULAR, aiTextureType_SPECULAR);
         GetMatColorOrTex(mat, m->emission, AI_MATKEY_COLOR_EMISSIVE, aiTextureType_EMISSIVE);
 
+        m->transparent = mat->Get(AI_MATKEY_OPACITY, m->transparency) == aiReturn_SUCCESS && m->transparency != 1.0;
+
         GetMatScalar(mat, m->shininess, AI_MATKEY_SHININESS);
     }
 }