diff --git a/Readme.md b/Readme.md
index d91f290fa..af831d2a5 100644
--- a/Readme.md
+++ b/Readme.md
@@ -15,6 +15,7 @@ Coverity
src="https://scan.coverity.com/projects/5607/badge.svg"/>
+Gitter chat: [](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
__[open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities.__
#### Supported file formats ####
diff --git a/code/FBXMeshGeometry.cpp b/code/FBXMeshGeometry.cpp
index e9d83911b..e7a105d45 100644
--- a/code/FBXMeshGeometry.cpp
+++ b/code/FBXMeshGeometry.cpp
@@ -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();
@@ -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:
@@ -191,84 +191,84 @@ MeshGeometry::~MeshGeometry()
// ------------------------------------------------------------------------------------------------
const std::vector& MeshGeometry::GetVertices() const {
- return vertices;
+ return m_vertices;
}
// ------------------------------------------------------------------------------------------------
const std::vector& MeshGeometry::GetNormals() const {
- return normals;
+ return m_normals;
}
// ------------------------------------------------------------------------------------------------
const std::vector& MeshGeometry::GetTangents() const {
- return tangents;
+ return m_tangents;
}
// ------------------------------------------------------------------------------------------------
const std::vector& MeshGeometry::GetBinormals() const {
- return binormals;
+ return m_binormals;
}
// ------------------------------------------------------------------------------------------------
const std::vector& MeshGeometry::GetFaceIndexCounts() const {
- return faces;
+ return m_faces;
}
// ------------------------------------------------------------------------------------------------
const std::vector& MeshGeometry::GetTextureCoords( unsigned int index ) const {
static const std::vector 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& MeshGeometry::GetVertexColors( unsigned int index ) const {
static const std::vector 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::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 ) );
}
// ------------------------------------------------------------------------------------------------
@@ -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& 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);
}
@@ -530,10 +530,10 @@ void MeshGeometry::ReadVertexDataUV(std::vector& 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);
}
@@ -545,10 +545,10 @@ void MeshGeometry::ReadVertexDataColors(std::vector& 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);
}
// ------------------------------------------------------------------------------------------------
@@ -564,10 +564,10 @@ void MeshGeometry::ReadVertexDataTangents(std::vector& 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);
}
// ------------------------------------------------------------------------------------------------
@@ -583,10 +583,10 @@ void MeshGeometry::ReadVertexDataBinormals(std::vector& 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);
}
@@ -595,7 +595,7 @@ void MeshGeometry::ReadVertexDataMaterials(std::vector& 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& 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: ")
diff --git a/code/FBXMeshGeometry.h b/code/FBXMeshGeometry.h
index 48ac550c1..690a86a01 100644
--- a/code/FBXMeshGeometry.h
+++ b/code/FBXMeshGeometry.h
@@ -156,21 +156,21 @@ private:
private:
// cached data arrays
- MatIndexArray materials;
- std::vector vertices;
- std::vector faces;
- mutable std::vector facesVertexStartIndices;
- std::vector tangents;
- std::vector binormals;
- std::vector normals;
+ MatIndexArray m_materials;
+ std::vector m_vertices;
+ std::vector m_faces;
+ mutable std::vector m_facesVertexStartIndices;
+ std::vector m_tangents;
+ std::vector m_binormals;
+ std::vector m_normals;
- std::string uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
- std::vector uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
- std::vector colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
+ std::string m_uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+ std::vector m_uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+ std::vector m_colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
- std::vector mapping_counts;
- std::vector mapping_offsets;
- std::vector mappings;
+ std::vector m_mapping_counts;
+ std::vector m_mapping_offsets;
+ std::vector m_mappings;
};
}
diff --git a/code/glTFAsset.inl b/code/glTFAsset.inl
index b9f3fccd8..64966fb28 100644
--- a/code/glTFAsset.inl
+++ b/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);
}
diff --git a/code/glTFAssetWriter.inl b/code/glTFAssetWriter.inl
index 119ebc937..af27604f2 100644
--- a/code/glTFAssetWriter.inl
+++ b/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);
diff --git a/code/glTFExporter.cpp b/code/glTFExporter.cpp
index 708570577..8f37452b1 100644
--- a/code/glTFExporter.cpp
+++ b/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);
}
}