Merge branch 'master' into fbx-keep-material-params

code/FBXConverter.cpp

@@ -870,10 +870,15 @@ namespace Assimp {
             for (const Geometry* geo : geos) {
 
                 const MeshGeometry* const mesh = dynamic_cast<const MeshGeometry*>(geo);
+                const LineGeometry* const line = dynamic_cast<const LineGeometry*>(geo);
                 if (mesh) {
                     const std::vector<unsigned int>& indices = ConvertMesh(*mesh, model, node_global_transform, nd);
                     std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
                 }
+                else if (line) {
+                    const std::vector<unsigned int>& indices = ConvertLine(*line, model, node_global_transform, nd);
+                    std::copy(indices.begin(), indices.end(), std::back_inserter(meshes));
+                }
                 else {
                     FBXImporter::LogWarn("ignoring unrecognized geometry: " + geo->Name());
                 }
@@ -922,7 +927,52 @@ namespace Assimp {
             return temp;
         }
 
-        aiMesh* FBXConverter::SetupEmptyMesh(const MeshGeometry& mesh, aiNode& nd)
+        std::vector<unsigned int> FBXConverter::ConvertLine(const LineGeometry& line, const Model& model,
+            const aiMatrix4x4& node_global_transform, aiNode& nd)
+        {
+            std::vector<unsigned int> temp;
+
+            const std::vector<aiVector3D>& vertices = line.GetVertices();
+            const std::vector<int>& indices = line.GetIndices();
+            if (vertices.empty() || indices.empty()) {
+                FBXImporter::LogWarn("ignoring empty line: " + line.Name());
+                return temp;
+            }
+
+            aiMesh* const out_mesh = SetupEmptyMesh(line, nd);
+            out_mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
+
+            // copy vertices
+            out_mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
+            out_mesh->mVertices = new aiVector3D[out_mesh->mNumVertices];
+            std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices);
+
+            //Number of line segments (faces) is "Number of Points - Number of Endpoints"
+            //N.B.: Endpoints in FbxLine are denoted by negative indices.
+            //If such an Index is encountered, add 1 and multiply by -1 to get the real index.
+            unsigned int epcount = 0;
+            for (unsigned i = 0; i < indices.size(); i++)
+            {
+                if (indices[i] < 0) epcount++;
+            }
+            unsigned int pcount = indices.size();
+            unsigned int scount = out_mesh->mNumFaces = pcount - epcount;
+
+            aiFace* fac = out_mesh->mFaces = new aiFace[scount]();
+            for (unsigned int i = 0; i < pcount; ++i) {
+                if (indices[i] < 0) continue;
+                aiFace& f = *fac++;
+                f.mNumIndices = 2; //2 == aiPrimitiveType_LINE 
+                f.mIndices = new unsigned int[2];
+                f.mIndices[0] = indices[i];
+                int segid = indices[(i + 1 == pcount ? 0 : i + 1)];   //If we have reached he last point, wrap around
+                f.mIndices[1] = (segid < 0 ? (segid + 1)*-1 : segid); //Convert EndPoint Index to normal Index
+            }
+            temp.push_back(static_cast<unsigned int>(meshes.size() - 1));
+            return temp;
+        }
+
+        aiMesh* FBXConverter::SetupEmptyMesh(const Geometry& mesh, aiNode& nd)
         {
             aiMesh* const out_mesh = new aiMesh();
             meshes.push_back(out_mesh);
@@ -957,6 +1007,7 @@ namespace Assimp {
             // copy vertices
             out_mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
             out_mesh->mVertices = new aiVector3D[vertices.size()];
+
             std::copy(vertices.begin(), vertices.end(), out_mesh->mVertices);
 
             // generate dummy faces

code/FBXConverter.h

@@ -181,7 +181,11 @@ private:
         const aiMatrix4x4& node_global_transform, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
-    aiMesh* SetupEmptyMesh(const MeshGeometry& mesh, aiNode& nd);
+    std::vector<unsigned int> ConvertLine(const LineGeometry& line, const Model& model,
+        const aiMatrix4x4& node_global_transform, aiNode& nd);
+
+    // ------------------------------------------------------------------------------------------------
+    aiMesh* SetupEmptyMesh(const Geometry& mesh, aiNode& nd);
 
     // ------------------------------------------------------------------------------------------------
     unsigned int ConvertMeshSingleMaterial(const MeshGeometry& mesh, const Model& model,
@@ -426,6 +430,7 @@ private:
     std::vector<aiCamera*> cameras;
     std::vector<aiTexture*> textures;
     
+
     typedef std::map<const Material*, unsigned int> MaterialMap;
     MaterialMap materials_converted;
 

code/FBXDocument.cpp

@@ -149,6 +149,9 @@ const Object* LazyObject::Get(bool dieOnError)
             if (!strcmp(classtag.c_str(), "Shape")) {
                 object.reset(new ShapeGeometry(id, element, name, doc));
             }
+            if (!strcmp(classtag.c_str(), "Line")) {
+                object.reset(new LineGeometry(id, element, name, doc));
+            }
         }
         else if (!strncmp(obtype,"NodeAttribute",length)) {
             if (!strcmp(classtag.c_str(),"Camera")) {

code/FBXDocument.h

@@ -66,6 +66,7 @@ class PropertyTable;
 class Document;
 class Material;
 class ShapeGeometry;
+class LineGeometry;
 class Geometry;
 
 class Video;

code/FBXMeshGeometry.cpp

@@ -679,6 +679,32 @@ const std::vector<aiVector3D>& ShapeGeometry::GetNormals() const {
 const std::vector<unsigned int>& ShapeGeometry::GetIndices() const {
     return m_indices;
 }
+// ------------------------------------------------------------------------------------------------
+LineGeometry::LineGeometry(uint64_t id, const Element& element, const std::string& name, const Document& doc)
+    : Geometry(id, element, name, doc)
+{
+    const Scope* sc = element.Compound();
+    if (!sc) {
+        DOMError("failed to read Geometry object (class: Line), no data scope found");
+    }
+    const Element& Points = GetRequiredElement(*sc, "Points", &element);
+    const Element& PointsIndex = GetRequiredElement(*sc, "PointsIndex", &element);
+    ParseVectorDataArray(m_vertices, Points);
+    ParseVectorDataArray(m_indices, PointsIndex);
+}
+
+// ------------------------------------------------------------------------------------------------
+LineGeometry::~LineGeometry() {
+    // empty
+}
+// ------------------------------------------------------------------------------------------------
+const std::vector<aiVector3D>& LineGeometry::GetVertices() const {
+    return m_vertices;
+}
+// ------------------------------------------------------------------------------------------------
+const std::vector<int>& LineGeometry::GetIndices() const {
+    return m_indices;
+}
 } // !FBX
 } // !Assimp
 #endif

code/FBXMeshGeometry.h

@@ -205,6 +205,28 @@ private:
     std::vector<aiVector3D> m_normals;
     std::vector<unsigned int> m_indices;
 };
+/**
+*  DOM class for FBX geometry of type "Line"
+*/
+class LineGeometry : public Geometry
+{
+public:
+    /** The class constructor */
+    LineGeometry(uint64_t id, const Element& element, const std::string& name, const Document& doc);
+
+    /** The class destructor */
+    virtual ~LineGeometry();
+
+    /** Get a list of all vertex points, non-unique*/
+    const std::vector<aiVector3D>& GetVertices() const;
+
+    /** Return list of vertex indices. */
+    const std::vector<int>& GetIndices() const;
+
+private:
+    std::vector<aiVector3D> m_vertices;
+    std::vector<int> m_indices;
+};
 
 }
 }