Revert "assimp: Sync with upstream 0201fc5"

This reverts commit 78b22393a8dd182ee56d0448ed77ba4430de5e75.

It caused a regression in FBX import leading to crashes.
Fixes #36908.

60 files changed, 1212 insertions, 1136 deletions

diff --git a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp b/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp
index 31c99ae94a..75daeb6b59 100644
--- a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp
@@ -2,7 +2,8 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
+
 
 All rights reserved.
 
@@ -35,6 +36,7 @@ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
 ----------------------------------------------------------------------
 */
 #include "ArmaturePopulate.h"
@@ -48,215 +50,219 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 /// The default class constructor.
-ArmaturePopulate::ArmaturePopulate() :
-        BaseProcess() {
-    // do nothing
-}
+ArmaturePopulate::ArmaturePopulate() : BaseProcess()
+{}
 
 /// The class destructor.
-ArmaturePopulate::~ArmaturePopulate() {
-    // do nothing
-}
+ArmaturePopulate::~ArmaturePopulate() 
+{}
 
 bool ArmaturePopulate::IsActive(unsigned int pFlags) const {
-    return (pFlags & aiProcess_PopulateArmatureData) != 0;
+  return (pFlags & aiProcess_PopulateArmatureData) != 0;
 }
 
 void ArmaturePopulate::SetupProperties(const Importer *pImp) {
-    // do nothing
+  // do nothing
 }
 
 void ArmaturePopulate::Execute(aiScene *out) {
 
-    // Now convert all bone positions to the correct mOffsetMatrix
-    std::vector<aiBone *> bones;
-    std::vector<aiNode *> nodes;
-    std::map<aiBone *, aiNode *> bone_stack;
-    BuildBoneList(out->mRootNode, out->mRootNode, out, bones);
-    BuildNodeList(out->mRootNode, nodes);
+  // Now convert all bone positions to the correct mOffsetMatrix
+  std::vector<aiBone *> bones;
+  std::vector<aiNode *> nodes;
+  std::map<aiBone *, aiNode *> bone_stack;
+  BuildBoneList(out->mRootNode, out->mRootNode, out, bones);
+  BuildNodeList(out->mRootNode, nodes);
 
-    BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
+  BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
 
-    ASSIMP_LOG_DEBUG_F("Bone stack size: ", bone_stack.size());
+  ASSIMP_LOG_DEBUG_F("Bone stack size: ", bone_stack.size());
 
-    for (std::pair<aiBone *, aiNode *> kvp : bone_stack) {
-        aiBone *bone = kvp.first;
-        aiNode *bone_node = kvp.second;
-        ASSIMP_LOG_DEBUG_F("active node lookup: ", bone->mName.C_Str());
-        // lcl transform grab - done in generate_nodes :)
+  for (std::pair<aiBone *, aiNode *> kvp : bone_stack) {
+    aiBone *bone = kvp.first;
+    aiNode *bone_node = kvp.second;
+    ASSIMP_LOG_DEBUG_F("active node lookup: ", bone->mName.C_Str());
+    // lcl transform grab - done in generate_nodes :)
 
-        // bone->mOffsetMatrix = bone_node->mTransformation;
-        aiNode *armature = GetArmatureRoot(bone_node, bones);
+    // bone->mOffsetMatrix = bone_node->mTransformation;
+    aiNode *armature = GetArmatureRoot(bone_node, bones);
 
-        ai_assert(armature);
+    ai_assert(armature);
 
-        // set up bone armature id
-        bone->mArmature = armature;
+    // set up bone armature id
+    bone->mArmature = armature;
 
-        // set this bone node to be referenced properly
-        ai_assert(bone_node);
-        bone->mNode = bone_node;
-    }
+    // set this bone node to be referenced properly
+    ai_assert(bone_node);
+    bone->mNode = bone_node;
+  }
 }
 
 
-// Reprocess all nodes to calculate bone transforms properly based on the REAL
-// mOffsetMatrix not the local.
-// Before this would use mesh transforms which is wrong for bone transforms
-// Before this would work for simple character skeletons but not complex meshes
-// with multiple origins
-// Source: sketch fab log cutter fbx
+/* Reprocess all nodes to calculate bone transforms properly based on the REAL
+ * mOffsetMatrix not the local. */
+/* Before this would use mesh transforms which is wrong for bone transforms */
+/* Before this would work for simple character skeletons but not complex meshes
+ * with multiple origins */
+/* Source: sketch fab log cutter fbx */
 void ArmaturePopulate::BuildBoneList(aiNode *current_node,
                                      const aiNode *root_node,
                                      const aiScene *scene,
                                      std::vector<aiBone *> &bones) {
-    ai_assert(scene);
-    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-        aiNode *child = current_node->mChildren[nodeId];
-        ai_assert(child);
-
-        // check for bones
-        for (unsigned int meshId = 0; meshId < child->mNumMeshes; ++meshId) {
-            ai_assert(child->mMeshes);
-            unsigned int mesh_index = child->mMeshes[meshId];
-            aiMesh *mesh = scene->mMeshes[mesh_index];
-            ai_assert(mesh);
-
-            for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
-                aiBone *bone = mesh->mBones[boneId];
-                ai_assert(bone);
-
-                // duplicate mehes exist with the same bones sometimes :)
-                // so this must be detected
-                if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
-                    // add the element once
-                    bones.push_back(bone);
-                }
-            }
-
-            // find mesh and get bones
-            // then do recursive lookup for bones in root node hierarchy
+  ai_assert(scene);
+  for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
+    aiNode *child = current_node->mChildren[nodeId];
+    ai_assert(child);
+
+    // check for bones
+    for (unsigned int meshId = 0; meshId < child->mNumMeshes; ++meshId) {
+      ai_assert(child->mMeshes);
+      unsigned int mesh_index = child->mMeshes[meshId];
+      aiMesh *mesh = scene->mMeshes[mesh_index];
+      ai_assert(mesh);
+
+      for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
+        aiBone *bone = mesh->mBones[boneId];
+        ai_assert(bone);
+
+        // duplicate meshes exist with the same bones sometimes :)
+        // so this must be detected
+        if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
+          // add the element once
+          bones.push_back(bone);
         }
+      }
 
-        BuildBoneList(child, root_node, scene, bones);
+      // find mesh and get bones
+      // then do recursive lookup for bones in root node hierarchy
     }
+
+    BuildBoneList(child, root_node, scene, bones);
+  }
 }
 
-// Prepare flat node list which can be used for non recursive lookups later
+/* Prepare flat node list which can be used for non recursive lookups later */
 void ArmaturePopulate::BuildNodeList(const aiNode *current_node,
                                      std::vector<aiNode *> &nodes) {
-    ai_assert(current_node);
+  ai_assert(current_node);
 
-    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-        aiNode *child = current_node->mChildren[nodeId];
-        ai_assert(child);
+  for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
+    aiNode *child = current_node->mChildren[nodeId];
+    ai_assert(child);
 
-        if (child->mNumMeshes == 0) {
-            nodes.push_back(child);
-        }
+    nodes.push_back(child);
 
-        BuildNodeList(child, nodes);
+    BuildNodeList(child, nodes);
   }
 }
 
-// A bone stack allows us to have multiple armatures, with the same bone names
-// A bone stack allows us also to retrieve bones true transform even with
-// duplicate names :)
+/* A bone stack allows us to have multiple armatures, with the same bone names
+ * A bone stack allows us also to retrieve bones true transform even with
+ * duplicate names :)
+ */
 void ArmaturePopulate::BuildBoneStack(aiNode *current_node,
                                       const aiNode *root_node,
                                       const aiScene *scene,
                                       const std::vector<aiBone *> &bones,
                                       std::map<aiBone *, aiNode *> &bone_stack,
-                                  std::vector<aiNode *> &node_stack) {
-    ai_assert(scene);
-    ai_assert(root_node);
-    ai_assert(!node_stack.empty());
-
-    for (aiBone *bone : bones) {
-        ai_assert(bone);
-        aiNode *node = GetNodeFromStack(bone->mName, node_stack);
-        if (node == nullptr) {
-            node_stack.clear();
-            BuildNodeList(root_node, node_stack);
-            ASSIMP_LOG_DEBUG_F("Resetting bone stack: nullptr element ", bone->mName.C_Str());
-
-            node = GetNodeFromStack(bone->mName, node_stack);
-
-            if (!node) {
-                ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
-                continue;
-            }
-        }
+                                      std::vector<aiNode *> &node_stack) {
+  ai_assert(scene);
+  ai_assert(root_node);
+  ai_assert(!node_stack.empty());
+
+  for (aiBone *bone : bones) {
+    ai_assert(bone);
+    aiNode *node = GetNodeFromStack(bone->mName, node_stack);
+    if (node == nullptr) {
+      node_stack.clear();
+      BuildNodeList(root_node, node_stack);
+      ASSIMP_LOG_DEBUG_F("Resetting bone stack: nullptr element ", bone->mName.C_Str());
+
+      node = GetNodeFromStack(bone->mName, node_stack);
+
+      if (!node) {
+        ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
+        continue;
+      }
+    }
 
-        ASSIMP_LOG_DEBUG_F("Successfully added bone[", bone->mName.C_Str(), "] to stack and bone node is: ", node->mName.C_Str());
+    ASSIMP_LOG_DEBUG_F("Successfully added bone[", bone->mName.C_Str(), "] to stack and bone node is: ", node->mName.C_Str());
 
-        bone_stack.insert(std::pair<aiBone *, aiNode *>(bone, node));
-    }
+    bone_stack.insert(std::pair<aiBone *, aiNode *>(bone, node));
+  }
 }
 
-// Returns the armature root node
-// This is required to be detected for a bone initially, it will recurse up
-// until it cannot find another bone and return the node No known failure
-// points. (yet)
+
+/* Returns the armature root node */
+/* This is required to be detected for a bone initially, it will recurse up
+ * until it cannot find another bone and return the node No known failure
+ * points. (yet)
+ */
 aiNode *ArmaturePopulate::GetArmatureRoot(aiNode *bone_node,
                                           std::vector<aiBone *> &bone_list) {
-    while (bone_node) {
-        if (!IsBoneNode(bone_node->mName, bone_list)) {
-            ASSIMP_LOG_DEBUG_F("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
-            return bone_node;
-        }
-
-        bone_node = bone_node->mParent;
+  while (bone_node) {
+    if (!IsBoneNode(bone_node->mName, bone_list)) {
+      ASSIMP_LOG_DEBUG_F("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
+      return bone_node;
     }
 
-    ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
-
-    return nullptr;
+    bone_node = bone_node->mParent;
+  }
+  
+  ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
+  
+  return nullptr;
 }
 
-// Simple IsBoneNode check if this could be a bone
+
+
+/* Simple IsBoneNode check if this could be a bone */
 bool ArmaturePopulate::IsBoneNode(const aiString &bone_name,
                                   std::vector<aiBone *> &bones) {
-    for (aiBone *bone : bones) {
-        if (bone->mName == bone_name) {
-            return true;
-        }
+  for (aiBone *bone : bones) {
+    if (bone->mName == bone_name) {
+      return true;
     }
+  }
 
-    return false;
+  return false;
 }
 
-// Pop this node by name from the stack if found
-// Used in multiple armature situations with duplicate node / bone names
-// Known flaw: cannot have nodes with bone names, will be fixed in later release
-// (serious to be fixed) Known flaw: nodes which have more than one bone could
-// be prematurely dropped from stack
+/* Pop this node by name from the stack if found */
+/* Used in multiple armature situations with duplicate node / bone names */
+/* Known flaw: cannot have nodes with bone names, will be fixed in later release
+ */
+/* (serious to be fixed) Known flaw: nodes which have more than one bone could
+ * be prematurely dropped from stack */
 aiNode *ArmaturePopulate::GetNodeFromStack(const aiString &node_name,
                                            std::vector<aiNode *> &nodes) {
-    std::vector<aiNode *>::iterator iter;
-    aiNode *found = nullptr;
-    for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
-        aiNode *element = *iter;
-        ai_assert(element);
-        // node valid and node name matches
-        if (element->mName == node_name) {
-            found = element;
-            break;
-        }
+  std::vector<aiNode *>::iterator iter;
+  aiNode *found = nullptr;
+  for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
+    aiNode *element = *iter;
+    ai_assert(element);
+    // node valid and node name matches
+    if (element->mName == node_name) {
+      found = element;
+      break;
     }
+  }
 
-    if (found != nullptr) {
-        ASSIMP_LOG_INFO_F("Removed node from stack: ", found->mName.C_Str());
-        // now pop the element from the node list
-        nodes.erase(iter);
+  if (found != nullptr) {
+    ASSIMP_LOG_INFO_F("Removed node from stack: ", found->mName.C_Str());
+    // now pop the element from the node list
+    nodes.erase(iter);
 
-        return found;
-    }
+    return found;
+  }
 
-    // unique names can cause this problem
-    ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
+  // unique names can cause this problem
+  ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
 
-    return nullptr;
+  return nullptr;
 }
 
+
+
+
 } // Namespace Assimp
diff --git a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h b/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h
index 8985e1d1d8..aa1ad7c80c 100644
--- a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h
+++ b/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp b/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp
index 4af335d2f0..a3f7dd2557 100644
--- a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h b/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h
index bdd5ca7faa..3568a624f8 100644
--- a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp b/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
index 1ebf798bd5..df4d44337d 100644
--- a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h b/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h
index b4ad0f501f..a6d36e06ea 100644
--- a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp b/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp
index 6ca73f10e9..b7cd4f0bc6 100644
--- a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h b/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h
index de984a1052..f32b91fc39 100644
--- a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -137,9 +137,8 @@ public:
     // -------------------------------------------------------------------
     void Execute( aiScene* pScene);
 
-public:
-    /** Some other types of post-processing require winding order flips */
-    static void ProcessMesh( aiMesh* pMesh);
+protected:
+    void ProcessMesh( aiMesh* pMesh);
 };
 
 // ---------------------------------------------------------------------------
diff --git a/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp b/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp
index 9d6313f71c..83b8336bc9 100644
--- a/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/DeboneProcess.h b/thirdparty/assimp/code/PostProcessing/DeboneProcess.h
index 31955f2bda..8b64c2acc6 100644
--- a/thirdparty/assimp/code/PostProcessing/DeboneProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/DeboneProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp b/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
index 1d7cf33b02..b11615bb82 100644
--- a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h b/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h
index b9e942d559..c710c5a5ee 100644
--- a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp b/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
index b187acf53c..739382a057 100644
--- a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -128,8 +128,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
     auto oldTextures = pScene->mTextures;
     pScene->mTextures = new aiTexture*[pScene->mNumTextures];
     ::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u));
-    delete [] oldTextures;
-    
+
     // Add the new texture
     auto pTexture = new aiTexture;
     pTexture->mHeight = 0; // Means that this is still compressed
diff --git a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h b/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h
index bbe2656f56..3c4b2eab4e 100644
--- a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp b/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp
index dfdfec6ccf..50fac46dba 100644
--- a/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp
+++ b/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/FindDegenerates.h b/thirdparty/assimp/code/PostProcessing/FindDegenerates.h
index 1edaab6570..7a15e77cf1 100644
--- a/thirdparty/assimp/code/PostProcessing/FindDegenerates.h
+++ b/thirdparty/assimp/code/PostProcessing/FindDegenerates.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp b/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp
index 9a4c6f53b8..64907458a1 100644
--- a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h b/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h
index dcac4bf839..64b838d7cc 100644
--- a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp b/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
index c557d7f707..016884c6e7 100644
--- a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h b/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h
index 50a2fe04c6..ce7375f34f 100644
--- a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp b/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp
index bb2aa06cc7..bbbe6899b4 100644
--- a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp
+++ b/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h b/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h
index c022d03640..f60ce596a4 100644
--- a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h
+++ b/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp b/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
index bfe016cf27..c013454fc3 100644
--- a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h b/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
index d93489a5bd..4b43c82a42 100644
--- a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp b/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
index 08a1d9aaef..028334dec7 100644
--- a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h b/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h
index 6e872af3a8..c641fd6353 100644
--- a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp b/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
index 1df3334107..3f6c2f86bd 100644
--- a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h b/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h
index 38104b3bf7..2ceee17e85 100644
--- a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp b/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp
index d72d15d3a7..d0a016fa42 100644
--- a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h b/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h
index 73e11f57bd..de25ecd9fb 100644
--- a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h
+++ b/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp b/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp
index 070c9636f2..f121fc60d3 100644
--- a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h b/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h
index 76e7cf061b..e017ae62db 100644
--- a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp b/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
index 1f1abfabb0..d560f19287 100644
--- a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h b/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
index 8bc321a3c5..73c2a68d53 100644
--- a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp b/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp
index 88bdb3124f..41f50a5ba5 100644
--- a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp
+++ b/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h b/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h
index 699cce30b4..8565d5933a 100644
--- a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h
+++ b/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp b/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp
index f3996c2752..5db51f58b6 100644
--- a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp
+++ b/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
@@ -43,13 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the aiProcess_OptimizGraph step
  */
 
+
 #ifndef ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
 
 #include "OptimizeGraph.h"
 #include "ProcessHelper.h"
-#include "ConvertToLHProcess.h"
-#include <assimp/Exceptional.h>
 #include <assimp/SceneCombiner.h>
+#include <assimp/Exceptional.h>
 #include <stdio.h>
 
 using namespace Assimp;
@@ -60,299 +60,292 @@ using namespace Assimp;
  * The unhashed variant should be faster, except for *very* large data sets
  */
 #ifdef AI_OG_USE_HASHING
-// Use our standard hashing function to compute the hash
-#define AI_OG_GETKEY(str) SuperFastHash(str.data, str.length)
+    // Use our standard hashing function to compute the hash
+#   define AI_OG_GETKEY(str) SuperFastHash(str.data,str.length)
 #else
-// Otherwise hope that std::string will utilize a static buffer
-// for shorter node names. This would avoid endless heap copying.
-#define AI_OG_GETKEY(str) std::string(str.data)
+    // Otherwise hope that std::string will utilize a static buffer
+    // for shorter node names. This would avoid endless heap copying.
+#   define AI_OG_GETKEY(str) std::string(str.data)
 #endif
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-OptimizeGraphProcess::OptimizeGraphProcess() :
-		mScene(),
-		nodes_in(),
-		nodes_out(),
-		count_merged() {
-	// empty
+OptimizeGraphProcess::OptimizeGraphProcess()
+: mScene()
+, nodes_in()
+, nodes_out()
+, count_merged() {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
 OptimizeGraphProcess::~OptimizeGraphProcess() {
-	// empty
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool OptimizeGraphProcess::IsActive(unsigned int pFlags) const {
-	return (0 != (pFlags & aiProcess_OptimizeGraph));
+bool OptimizeGraphProcess::IsActive( unsigned int pFlags) const {
+    return (0 != (pFlags & aiProcess_OptimizeGraph));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup properties for the post-processing step
-void OptimizeGraphProcess::SetupProperties(const Importer *pImp) {
-	// Get value of AI_CONFIG_PP_OG_EXCLUDE_LIST
-	std::string tmp = pImp->GetPropertyString(AI_CONFIG_PP_OG_EXCLUDE_LIST, "");
-	AddLockedNodeList(tmp);
+void OptimizeGraphProcess::SetupProperties(const Importer* pImp) {
+    // Get value of AI_CONFIG_PP_OG_EXCLUDE_LIST
+    std::string tmp = pImp->GetPropertyString(AI_CONFIG_PP_OG_EXCLUDE_LIST,"");
+    AddLockedNodeList(tmp);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Collect new children
-void OptimizeGraphProcess::CollectNewChildren(aiNode *nd, std::list<aiNode *> &nodes) {
-	nodes_in += nd->mNumChildren;
-
-	// Process children
-	std::list<aiNode *> child_nodes;
-	for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
-		CollectNewChildren(nd->mChildren[i], child_nodes);
-		nd->mChildren[i] = nullptr;
-	}
-
-	// Check whether we need this node; if not we can replace it by our own children (warn, danger of incest).
-	if (locked.find(AI_OG_GETKEY(nd->mName)) == locked.end()) {
-		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
-
-			if (locked.find(AI_OG_GETKEY((*it)->mName)) == locked.end()) {
-				(*it)->mTransformation = nd->mTransformation * (*it)->mTransformation;
-				nodes.push_back(*it);
-
-				it = child_nodes.erase(it);
-				continue;
-			}
-			++it;
-		}
-
-		if (nd->mNumMeshes || !child_nodes.empty()) {
-			nodes.push_back(nd);
-		} else {
-			delete nd; /* bye, node */
-			return;
-		}
-	} else {
-
-		// Retain our current position in the hierarchy
-		nodes.push_back(nd);
-
-		// Now check for possible optimizations in our list of child nodes. join as many as possible
-		aiNode *join_master = nullptr;
-		aiMatrix4x4 inv;
-
-		const LockedSetType::const_iterator end = locked.end();
-
-		std::list<aiNode *> join;
-		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
-			aiNode *child = *it;
-			if (child->mNumChildren == 0 && locked.find(AI_OG_GETKEY(child->mName)) == end) {
-
-				// There may be no instanced meshes
-				unsigned int n = 0;
-				for (; n < child->mNumMeshes; ++n) {
-					if (meshes[child->mMeshes[n]] > 1) {
-						break;
-					}
-				}
-				if (n == child->mNumMeshes) {
-					if (!join_master) {
-						join_master = child;
-						inv = join_master->mTransformation;
-						inv.Inverse();
-					} else {
-						child->mTransformation = inv * child->mTransformation;
-
-						join.push_back(child);
-						it = child_nodes.erase(it);
-						continue;
-					}
-				}
-			}
-			++it;
-		}
-		if (join_master && !join.empty()) {
-			join_master->mName.length = ::ai_snprintf(join_master->mName.data, MAXLEN, "$MergedNode_%i", count_merged++);
-
-			unsigned int out_meshes = 0;
-			for (std::list<aiNode *>::const_iterator it = join.cbegin(); it != join.cend(); ++it) {
-				out_meshes += (*it)->mNumMeshes;
-			}
-
-			// copy all mesh references in one array
-			if (out_meshes) {
-				unsigned int *meshes = new unsigned int[out_meshes + join_master->mNumMeshes], *tmp = meshes;
-				for (unsigned int n = 0; n < join_master->mNumMeshes; ++n) {
-					*tmp++ = join_master->mMeshes[n];
-				}
-
-				for (const aiNode *join_node : join) {
-					for (unsigned int n = 0; n < join_node->mNumMeshes; ++n) {
-
-						*tmp = join_node->mMeshes[n];
-						aiMesh *mesh = mScene->mMeshes[*tmp++];
-
-						// Assume the transformation is affine
-						// manually move the mesh into the right coordinate system
-
-						// Check for odd negative scale (mirror)
-						if (join_node->mTransformation.Determinant() < 0) {
-							// Reverse the mesh face winding order
-                            FlipWindingOrderProcess::ProcessMesh(mesh);
-						}
-
-                        // Update positions, normals and tangents
-						const aiMatrix3x3 IT = aiMatrix3x3(join_node->mTransformation).Inverse().Transpose();
-						for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
-
-							mesh->mVertices[a] *= join_node->mTransformation;
-
-							if (mesh->HasNormals())
-								mesh->mNormals[a] *= IT;
-
-							if (mesh->HasTangentsAndBitangents()) {
-								mesh->mTangents[a] *= IT;
-								mesh->mBitangents[a] *= IT;
-							}
-						}
-					}
-					delete join_node; // bye, node
-				}
-				delete[] join_master->mMeshes;
-				join_master->mMeshes = meshes;
-				join_master->mNumMeshes += out_meshes;
-			}
-		}
-	}
-	// reassign children if something changed
-	if (child_nodes.empty() || child_nodes.size() > nd->mNumChildren) {
-
-		delete[] nd->mChildren;
-
-		if (!child_nodes.empty()) {
-			nd->mChildren = new aiNode *[child_nodes.size()];
-		} else
-			nd->mChildren = nullptr;
-	}
-
-	nd->mNumChildren = static_cast<unsigned int>(child_nodes.size());
-
-	if (nd->mChildren) {
-		aiNode **tmp = nd->mChildren;
-		for (std::list<aiNode *>::iterator it = child_nodes.begin(); it != child_nodes.end(); ++it) {
-			aiNode *node = *tmp++ = *it;
-			node->mParent = nd;
-		}
-	}
-
-	nodes_out += static_cast<unsigned int>(child_nodes.size());
+void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& nodes) {
+    nodes_in += nd->mNumChildren;
+
+    // Process children
+    std::list<aiNode*> child_nodes;
+    for (unsigned int i = 0; i < nd->mNumChildren; ++i) {
+        CollectNewChildren(nd->mChildren[i],child_nodes);
+        nd->mChildren[i] = nullptr;
+    }
+
+    // Check whether we need this node; if not we can replace it by our own children (warn, danger of incest).
+    if (locked.find(AI_OG_GETKEY(nd->mName)) == locked.end() ) {
+        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end();) {
+
+            if (locked.find(AI_OG_GETKEY((*it)->mName)) == locked.end()) {
+                (*it)->mTransformation = nd->mTransformation * (*it)->mTransformation;
+                nodes.push_back(*it);
+
+                it = child_nodes.erase(it);
+                continue;
+            }
+            ++it;
+        }
+
+        if (nd->mNumMeshes || !child_nodes.empty()) {
+            nodes.push_back(nd);
+        } else {
+            delete nd; /* bye, node */
+            return;
+        }
+    } else {
+
+        // Retain our current position in the hierarchy
+        nodes.push_back(nd);
+
+        // Now check for possible optimizations in our list of child nodes. join as many as possible
+        aiNode* join_master = NULL;
+        aiMatrix4x4 inv;
+
+        const LockedSetType::const_iterator end = locked.end();
+
+        std::list<aiNode*> join;
+        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end();)   {
+            aiNode* child = *it;
+            if (child->mNumChildren == 0 && locked.find(AI_OG_GETKEY(child->mName)) == end) {
+
+                // There may be no instanced meshes
+                unsigned int n = 0;
+                for (; n < child->mNumMeshes;++n) {
+                    if (meshes[child->mMeshes[n]] > 1) {
+                        break;
+                    }
+                }
+                if (n == child->mNumMeshes) {
+                    if (!join_master) {
+                        join_master = child;
+                        inv = join_master->mTransformation;
+                        inv.Inverse();
+                    } else {
+                        child->mTransformation = inv * child->mTransformation ;
+
+                        join.push_back(child);
+                        it = child_nodes.erase(it);
+                        continue;
+                    }
+                }
+            }
+            ++it;
+        }
+        if (join_master && !join.empty()) {
+            join_master->mName.length = ::ai_snprintf(join_master->mName.data, MAXLEN, "$MergedNode_%i",count_merged++);
+
+            unsigned int out_meshes = 0;
+            for (std::list<aiNode*>::iterator it = join.begin(); it != join.end(); ++it) {
+                out_meshes += (*it)->mNumMeshes;
+            }
+
+            // copy all mesh references in one array
+            if (out_meshes) {
+                unsigned int* meshes = new unsigned int[out_meshes+join_master->mNumMeshes], *tmp = meshes;
+                for (unsigned int n = 0; n < join_master->mNumMeshes;++n) {
+                    *tmp++ = join_master->mMeshes[n];
+                }
+
+                for (std::list<aiNode*>::iterator it = join.begin(); it != join.end(); ++it) {
+                    for (unsigned int n = 0; n < (*it)->mNumMeshes; ++n) {
+
+                        *tmp = (*it)->mMeshes[n];
+                        aiMesh* mesh = mScene->mMeshes[*tmp++];
+
+                        // manually move the mesh into the right coordinate system
+                        const aiMatrix3x3 IT = aiMatrix3x3( (*it)->mTransformation ).Inverse().Transpose();
+                        for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
+
+                            mesh->mVertices[a] *= (*it)->mTransformation;
+
+                            if (mesh->HasNormals())
+                                mesh->mNormals[a] *= IT;
+
+                            if (mesh->HasTangentsAndBitangents()) {
+                                mesh->mTangents[a] *= IT;
+                                mesh->mBitangents[a] *= IT;
+                            }
+                        }
+                    }
+                    delete *it; // bye, node
+                }
+                delete[] join_master->mMeshes;
+                join_master->mMeshes = meshes;
+                join_master->mNumMeshes += out_meshes;
+            }
+        }
+    }
+    // reassign children if something changed
+    if (child_nodes.empty() || child_nodes.size() > nd->mNumChildren) {
+
+        delete[] nd->mChildren;
+
+        if (!child_nodes.empty()) {
+            nd->mChildren = new aiNode*[child_nodes.size()];
+        }
+        else nd->mChildren = nullptr;
+    }
+
+    nd->mNumChildren = static_cast<unsigned int>(child_nodes.size());
+
+    if (nd->mChildren) {
+        aiNode** tmp = nd->mChildren;
+        for (std::list<aiNode*>::iterator it = child_nodes.begin(); it != child_nodes.end(); ++it) {
+            aiNode* node = *tmp++ = *it;
+            node->mParent = nd;
+        }
+    }
+
+    nodes_out += static_cast<unsigned int>(child_nodes.size());
 }
 
 // ------------------------------------------------------------------------------------------------
 // Execute the post-processing step on the given scene
-void OptimizeGraphProcess::Execute(aiScene *pScene) {
-	ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
-	nodes_in = nodes_out = count_merged = 0;
-	mScene = pScene;
+void OptimizeGraphProcess::Execute( aiScene* pScene) {
+    ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
+    nodes_in = nodes_out = count_merged = 0;
+    mScene = pScene;
 
-	meshes.resize(pScene->mNumMeshes, 0);
-	FindInstancedMeshes(pScene->mRootNode);
+    meshes.resize(pScene->mNumMeshes,0);
+    FindInstancedMeshes(pScene->mRootNode);
 
-	// build a blacklist of identifiers. If the name of a node matches one of these, we won't touch it
-	locked.clear();
-	for (std::list<std::string>::const_iterator it = locked_nodes.begin(); it != locked_nodes.end(); ++it) {
+    // build a blacklist of identifiers. If the name of a node matches one of these, we won't touch it
+    locked.clear();
+    for (std::list<std::string>::const_iterator it = locked_nodes.begin(); it != locked_nodes.end(); ++it) {
 #ifdef AI_OG_USE_HASHING
-		locked.insert(SuperFastHash((*it).c_str()));
+        locked.insert(SuperFastHash((*it).c_str()));
 #else
-		locked.insert(*it);
+        locked.insert(*it);
 #endif
-	}
-
-	for (unsigned int i = 0; i < pScene->mNumAnimations; ++i) {
-		for (unsigned int a = 0; a < pScene->mAnimations[i]->mNumChannels; ++a) {
-			aiNodeAnim *anim = pScene->mAnimations[i]->mChannels[a];
-			locked.insert(AI_OG_GETKEY(anim->mNodeName));
-		}
-	}
-
-	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-		for (unsigned int a = 0; a < pScene->mMeshes[i]->mNumBones; ++a) {
-
-			aiBone *bone = pScene->mMeshes[i]->mBones[a];
-			locked.insert(AI_OG_GETKEY(bone->mName));
-
-			// HACK: Meshes referencing bones may not be transformed; we need to look them.
-			// The easiest way to do this is to increase their reference counters ...
-			meshes[i] += 2;
-		}
-	}
-
-	for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
-		aiCamera *cam = pScene->mCameras[i];
-		locked.insert(AI_OG_GETKEY(cam->mName));
-	}
-
-	for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
-		aiLight *lgh = pScene->mLights[i];
-		locked.insert(AI_OG_GETKEY(lgh->mName));
-	}
-
-	// Insert a dummy master node and make it read-only
-	aiNode *dummy_root = new aiNode(AI_RESERVED_NODE_NAME);
-	locked.insert(AI_OG_GETKEY(dummy_root->mName));
-
-	const aiString prev = pScene->mRootNode->mName;
-	pScene->mRootNode->mParent = dummy_root;
-
-	dummy_root->mChildren = new aiNode *[dummy_root->mNumChildren = 1];
-	dummy_root->mChildren[0] = pScene->mRootNode;
-
-	// Do our recursive processing of scenegraph nodes. For each node collect
-	// a fully new list of children and allow their children to place themselves
-	// on the same hierarchy layer as their parents.
-	std::list<aiNode *> nodes;
-	CollectNewChildren(dummy_root, nodes);
-
-	ai_assert(nodes.size() == 1);
-
-	if (dummy_root->mNumChildren == 0) {
-		pScene->mRootNode = nullptr;
-		throw DeadlyImportError("After optimizing the scene graph, no data remains");
-	}
-
-	if (dummy_root->mNumChildren > 1) {
-		pScene->mRootNode = dummy_root;
-
-		// Keep the dummy node but assign the name of the old root node to it
-		pScene->mRootNode->mName = prev;
-	} else {
-
-		// Remove the dummy root node again.
-		pScene->mRootNode = dummy_root->mChildren[0];
-
-		dummy_root->mChildren[0] = nullptr;
-		delete dummy_root;
-	}
-
-	pScene->mRootNode->mParent = nullptr;
-	if (!DefaultLogger::isNullLogger()) {
-		if (nodes_in != nodes_out) {
-			ASSIMP_LOG_INFO_F("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
-		} else {
-			ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
-		}
-	}
-	meshes.clear();
-	locked.clear();
+    }
+
+    for (unsigned int i = 0; i < pScene->mNumAnimations; ++i) {
+        for (unsigned int a = 0; a < pScene->mAnimations[i]->mNumChannels; ++a) {
+            aiNodeAnim* anim = pScene->mAnimations[i]->mChannels[a];
+            locked.insert(AI_OG_GETKEY(anim->mNodeName));
+        }
+    }
+
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        for (unsigned int a = 0; a < pScene->mMeshes[i]->mNumBones; ++a) {
+
+            aiBone* bone = pScene->mMeshes[i]->mBones[a];
+            locked.insert(AI_OG_GETKEY(bone->mName));
+
+            // HACK: Meshes referencing bones may not be transformed; we need to look them.
+            // The easiest way to do this is to increase their reference counters ...
+            meshes[i] += 2;
+        }
+    }
+
+    for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
+        aiCamera* cam = pScene->mCameras[i];
+        locked.insert(AI_OG_GETKEY(cam->mName));
+    }
+
+    for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
+        aiLight* lgh = pScene->mLights[i];
+        locked.insert(AI_OG_GETKEY(lgh->mName));
+    }
+
+    // Insert a dummy master node and make it read-only
+    aiNode* dummy_root = new aiNode(AI_RESERVED_NODE_NAME);
+    locked.insert(AI_OG_GETKEY(dummy_root->mName));
+
+    const aiString prev = pScene->mRootNode->mName;
+    pScene->mRootNode->mParent = dummy_root;
+
+    dummy_root->mChildren = new aiNode*[dummy_root->mNumChildren = 1];
+    dummy_root->mChildren[0] = pScene->mRootNode;
+
+    // Do our recursive processing of scenegraph nodes. For each node collect
+    // a fully new list of children and allow their children to place themselves
+    // on the same hierarchy layer as their parents.
+    std::list<aiNode*> nodes;
+    CollectNewChildren (dummy_root,nodes);
+
+    ai_assert(nodes.size() == 1);
+
+    if (dummy_root->mNumChildren == 0) {
+        pScene->mRootNode = NULL;
+        throw DeadlyImportError("After optimizing the scene graph, no data remains");
+    }
+
+    if (dummy_root->mNumChildren > 1) {
+        pScene->mRootNode = dummy_root;
+
+        // Keep the dummy node but assign the name of the old root node to it
+        pScene->mRootNode->mName = prev;
+    }
+    else {
+
+        // Remove the dummy root node again.
+        pScene->mRootNode = dummy_root->mChildren[0];
+
+        dummy_root->mChildren[0] = NULL;
+        delete dummy_root;
+    }
+
+    pScene->mRootNode->mParent = NULL;
+    if (!DefaultLogger::isNullLogger()) {
+        if ( nodes_in != nodes_out) {
+            ASSIMP_LOG_INFO_F("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
+        } else {
+            ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
+        }
+    }
+    meshes.clear();
+    locked.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a LUT of all instanced meshes
-void OptimizeGraphProcess::FindInstancedMeshes(aiNode *pNode) {
-	for (unsigned int i = 0; i < pNode->mNumMeshes; ++i) {
-		++meshes[pNode->mMeshes[i]];
-	}
-
-	for (unsigned int i = 0; i < pNode->mNumChildren; ++i)
-		FindInstancedMeshes(pNode->mChildren[i]);
+void OptimizeGraphProcess::FindInstancedMeshes (aiNode* pNode)
+{
+    for (unsigned int i = 0; i < pNode->mNumMeshes;++i) {
+        ++meshes[pNode->mMeshes[i]];
+    }
+
+    for (unsigned int i = 0; i < pNode->mNumChildren; ++i)
+        FindInstancedMeshes(pNode->mChildren[i]);
 }
 
 #endif // !! ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h b/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h
index 34f70854f7..82cc5db3fe 100644
--- a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h
+++ b/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -75,13 +75,13 @@ public:
     ~OptimizeGraphProcess();
 
     // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const override;
+    bool IsActive( unsigned int pFlags) const;
 
     // -------------------------------------------------------------------
-    void Execute( aiScene* pScene) override;
+    void Execute( aiScene* pScene);
 
     // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp) override;
+    void SetupProperties(const Importer* pImp);
 
     // -------------------------------------------------------------------
     /** @brief Add a list of node names to be locked and not modified.
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp b/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp
index 983d8001f3..3f6765f6ca 100644
--- a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp
+++ b/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h b/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h
index 50dfe2957e..dec4ab52de 100644
--- a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h
+++ b/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp b/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp
index 293a5c0ea9..52001a0578 100644
--- a/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp
+++ b/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -45,11 +45,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the "PretransformVertices" post processing step
 */
 
+
 #include "PretransformVertices.h"
-#include "ConvertToLHProcess.h"
 #include "ProcessHelper.h"
-#include <assimp/Exceptional.h>
 #include <assimp/SceneCombiner.h>
+#include <assimp/Exceptional.h>
 
 using namespace Assimp;
 
@@ -59,630 +59,670 @@ using namespace Assimp;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-PretransformVertices::PretransformVertices() :
-		configKeepHierarchy(false),
-		configNormalize(false),
-		configTransform(false),
-		configTransformation(),
-		mConfigPointCloud(false) {
-	// empty
+PretransformVertices::PretransformVertices()
+: configKeepHierarchy (false)
+, configNormalize(false)
+, configTransform(false)
+, configTransformation()
+, mConfigPointCloud( false ) {
+    // empty
 }
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
 PretransformVertices::~PretransformVertices() {
-	// nothing to do here
+    // nothing to do here
 }
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the processing step is present in the given flag field.
-bool PretransformVertices::IsActive(unsigned int pFlags) const {
-	return (pFlags & aiProcess_PreTransformVertices) != 0;
+bool PretransformVertices::IsActive( unsigned int pFlags) const
+{
+    return  (pFlags & aiProcess_PreTransformVertices) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import configuration
-void PretransformVertices::SetupProperties(const Importer *pImp) {
-	// Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
-	// AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
-	configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY, 0));
-	configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE, 0));
-	configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION, 0));
+void PretransformVertices::SetupProperties(const Importer* pImp)
+{
+    // Get the current value of AI_CONFIG_PP_PTV_KEEP_HIERARCHY, AI_CONFIG_PP_PTV_NORMALIZE,
+    // AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION and AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION
+    configKeepHierarchy = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_KEEP_HIERARCHY,0));
+    configNormalize = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_NORMALIZE,0));
+    configTransform = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_PTV_ADD_ROOT_TRANSFORMATION,0));
 
-	configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
+    configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
 
-	mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
+    mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Count the number of nodes
-unsigned int PretransformVertices::CountNodes(const aiNode *pcNode) const {
-	unsigned int iRet = 1;
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		iRet += CountNodes(pcNode->mChildren[i]);
-	}
-	return iRet;
+unsigned int PretransformVertices::CountNodes( aiNode* pcNode )
+{
+    unsigned int iRet = 1;
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)
+    {
+        iRet += CountNodes(pcNode->mChildren[i]);
+    }
+    return iRet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a bitwise combination identifying the vertex format of a mesh
-unsigned int PretransformVertices::GetMeshVFormat(aiMesh *pcMesh) const {
-	// the vertex format is stored in aiMesh::mBones for later retrieval.
-	// there isn't a good reason to compute it a few hundred times
-	// from scratch. The pointer is unused as animations are lost
-	// during PretransformVertices.
-	if (pcMesh->mBones)
-		return (unsigned int)(uint64_t)pcMesh->mBones;
-
-	const unsigned int iRet = GetMeshVFormatUnique(pcMesh);
-
-	// store the value for later use
-	pcMesh->mBones = (aiBone **)(uint64_t)iRet;
-	return iRet;
+unsigned int PretransformVertices::GetMeshVFormat( aiMesh* pcMesh )
+{
+    // the vertex format is stored in aiMesh::mBones for later retrieval.
+    // there isn't a good reason to compute it a few hundred times
+    // from scratch. The pointer is unused as animations are lost
+    // during PretransformVertices.
+    if (pcMesh->mBones)
+        return (unsigned int)(uint64_t)pcMesh->mBones;
+
+
+    const unsigned int iRet = GetMeshVFormatUnique(pcMesh);
+
+    // store the value for later use
+    pcMesh->mBones = (aiBone**)(uint64_t)iRet;
+    return iRet;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Count the number of vertices in the whole scene and a given
 // material index
-void PretransformVertices::CountVerticesAndFaces(const aiScene *pcScene, const aiNode *pcNode, unsigned int iMat,
-		unsigned int iVFormat, unsigned int *piFaces, unsigned int *piVertices) const {
-	for (unsigned int i = 0; i < pcNode->mNumMeshes; ++i) {
-		aiMesh *pcMesh = pcScene->mMeshes[pcNode->mMeshes[i]];
-		if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh)) {
-			*piVertices += pcMesh->mNumVertices;
-			*piFaces += pcMesh->mNumFaces;
-		}
-	}
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		CountVerticesAndFaces(pcScene, pcNode->mChildren[i], iMat,
-				iVFormat, piFaces, piVertices);
-	}
+void PretransformVertices::CountVerticesAndFaces( aiScene* pcScene, aiNode* pcNode, unsigned int iMat,
+    unsigned int iVFormat, unsigned int* piFaces, unsigned int* piVertices)
+{
+    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
+    {
+        aiMesh* pcMesh = pcScene->mMeshes[ pcNode->mMeshes[i] ];
+        if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh))
+        {
+            *piVertices += pcMesh->mNumVertices;
+            *piFaces += pcMesh->mNumFaces;
+        }
+    }
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)
+    {
+        CountVerticesAndFaces(pcScene,pcNode->mChildren[i],iMat,
+            iVFormat,piFaces,piVertices);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Collect vertex/face data
-void PretransformVertices::CollectData(const aiScene *pcScene, const aiNode *pcNode, unsigned int iMat,
-		unsigned int iVFormat, aiMesh *pcMeshOut,
-		unsigned int aiCurrent[2], unsigned int *num_refs) const {
-	// No need to multiply if there's no transformation
-	const bool identity = pcNode->mTransformation.IsIdentity();
-	for (unsigned int i = 0; i < pcNode->mNumMeshes; ++i) {
-		aiMesh *pcMesh = pcScene->mMeshes[pcNode->mMeshes[i]];
-		if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh)) {
-			// Decrement mesh reference counter
-			unsigned int &num_ref = num_refs[pcNode->mMeshes[i]];
-			ai_assert(0 != num_ref);
-			--num_ref;
-			// Save the name of the last mesh
-			if (num_ref == 0) {
-				pcMeshOut->mName = pcMesh->mName;
-			}
-
-			if (identity) {
-				// copy positions without modifying them
-				::memcpy(pcMeshOut->mVertices + aiCurrent[AI_PTVS_VERTEX],
-						pcMesh->mVertices,
-						pcMesh->mNumVertices * sizeof(aiVector3D));
-
-				if (iVFormat & 0x2) {
-					// copy normals without modifying them
-					::memcpy(pcMeshOut->mNormals + aiCurrent[AI_PTVS_VERTEX],
-							pcMesh->mNormals,
-							pcMesh->mNumVertices * sizeof(aiVector3D));
-				}
-				if (iVFormat & 0x4) {
-					// copy tangents without modifying them
-					::memcpy(pcMeshOut->mTangents + aiCurrent[AI_PTVS_VERTEX],
-							pcMesh->mTangents,
-							pcMesh->mNumVertices * sizeof(aiVector3D));
-					// copy bitangents without modifying them
-					::memcpy(pcMeshOut->mBitangents + aiCurrent[AI_PTVS_VERTEX],
-							pcMesh->mBitangents,
-							pcMesh->mNumVertices * sizeof(aiVector3D));
-				}
-			} else {
-				// copy positions, transform them to worldspace
-				for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
-					pcMeshOut->mVertices[aiCurrent[AI_PTVS_VERTEX] + n] = pcNode->mTransformation * pcMesh->mVertices[n];
-				}
-				aiMatrix4x4 mWorldIT = pcNode->mTransformation;
-				mWorldIT.Inverse().Transpose();
-
-				// TODO: implement Inverse() for aiMatrix3x3
-				aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
-
-				if (iVFormat & 0x2) {
-					// copy normals, transform them to worldspace
-					for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
-						pcMeshOut->mNormals[aiCurrent[AI_PTVS_VERTEX] + n] =
-								(m * pcMesh->mNormals[n]).Normalize();
-					}
-				}
-				if (iVFormat & 0x4) {
-					// copy tangents and bitangents, transform them to worldspace
-					for (unsigned int n = 0; n < pcMesh->mNumVertices; ++n) {
-						pcMeshOut->mTangents[aiCurrent[AI_PTVS_VERTEX] + n] = (m * pcMesh->mTangents[n]).Normalize();
-						pcMeshOut->mBitangents[aiCurrent[AI_PTVS_VERTEX] + n] = (m * pcMesh->mBitangents[n]).Normalize();
-					}
-				}
-			}
-			unsigned int p = 0;
-			while (iVFormat & (0x100 << p)) {
-				// copy texture coordinates
-				memcpy(pcMeshOut->mTextureCoords[p] + aiCurrent[AI_PTVS_VERTEX],
-						pcMesh->mTextureCoords[p],
-						pcMesh->mNumVertices * sizeof(aiVector3D));
-				++p;
-			}
-			p = 0;
-			while (iVFormat & (0x1000000 << p)) {
-				// copy vertex colors
-				memcpy(pcMeshOut->mColors[p] + aiCurrent[AI_PTVS_VERTEX],
-						pcMesh->mColors[p],
-						pcMesh->mNumVertices * sizeof(aiColor4D));
-				++p;
-			}
-			// now we need to copy all faces. since we will delete the source mesh afterwards,
-			// we don't need to reallocate the array of indices except if this mesh is
-			// referenced multiple times.
-			for (unsigned int planck = 0; planck < pcMesh->mNumFaces; ++planck) {
-				aiFace &f_src = pcMesh->mFaces[planck];
-				aiFace &f_dst = pcMeshOut->mFaces[aiCurrent[AI_PTVS_FACE] + planck];
-
-				const unsigned int num_idx = f_src.mNumIndices;
-
-				f_dst.mNumIndices = num_idx;
-
-				unsigned int *pi;
-				if (!num_ref) { /* if last time the mesh is referenced -> no reallocation */
-					pi = f_dst.mIndices = f_src.mIndices;
-
-					// offset all vertex indices
-					for (unsigned int hahn = 0; hahn < num_idx; ++hahn) {
-						pi[hahn] += aiCurrent[AI_PTVS_VERTEX];
-					}
-				} else {
-					pi = f_dst.mIndices = new unsigned int[num_idx];
-
-					// copy and offset all vertex indices
-					for (unsigned int hahn = 0; hahn < num_idx; ++hahn) {
-						pi[hahn] = f_src.mIndices[hahn] + aiCurrent[AI_PTVS_VERTEX];
-					}
-				}
-
-				// Update the mPrimitiveTypes member of the mesh
-				switch (pcMesh->mFaces[planck].mNumIndices) {
-					case 0x1:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POINT;
-						break;
-					case 0x2:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_LINE;
-						break;
-					case 0x3:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-						break;
-					default:
-						pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-						break;
-				};
-			}
-			aiCurrent[AI_PTVS_VERTEX] += pcMesh->mNumVertices;
-			aiCurrent[AI_PTVS_FACE] += pcMesh->mNumFaces;
-		}
-	}
-
-	// append all children of us
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		CollectData(pcScene, pcNode->mChildren[i], iMat,
-				iVFormat, pcMeshOut, aiCurrent, num_refs);
-	}
+void PretransformVertices::CollectData( aiScene* pcScene, aiNode* pcNode, unsigned int iMat,
+    unsigned int iVFormat, aiMesh* pcMeshOut,
+    unsigned int aiCurrent[2], unsigned int* num_refs)
+{
+    // No need to multiply if there's no transformation
+    const bool identity = pcNode->mTransformation.IsIdentity();
+    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i)
+    {
+        aiMesh* pcMesh = pcScene->mMeshes[ pcNode->mMeshes[i] ];
+        if (iMat == pcMesh->mMaterialIndex && iVFormat == GetMeshVFormat(pcMesh))
+        {
+            // Decrement mesh reference counter
+            unsigned int& num_ref = num_refs[pcNode->mMeshes[i]];
+            ai_assert(0 != num_ref);
+            --num_ref;
+            // Save the name of the last mesh
+            if (num_ref==0)
+            {
+                pcMeshOut->mName = pcMesh->mName;
+            }
+
+            if (identity)   {
+                // copy positions without modifying them
+                ::memcpy(pcMeshOut->mVertices + aiCurrent[AI_PTVS_VERTEX],
+                    pcMesh->mVertices,
+                    pcMesh->mNumVertices * sizeof(aiVector3D));
+
+                if (iVFormat & 0x2) {
+                    // copy normals without modifying them
+                    ::memcpy(pcMeshOut->mNormals + aiCurrent[AI_PTVS_VERTEX],
+                        pcMesh->mNormals,
+                        pcMesh->mNumVertices * sizeof(aiVector3D));
+                }
+                if (iVFormat & 0x4)
+                {
+                    // copy tangents without modifying them
+                    ::memcpy(pcMeshOut->mTangents + aiCurrent[AI_PTVS_VERTEX],
+                        pcMesh->mTangents,
+                        pcMesh->mNumVertices * sizeof(aiVector3D));
+                    // copy bitangents without modifying them
+                    ::memcpy(pcMeshOut->mBitangents + aiCurrent[AI_PTVS_VERTEX],
+                        pcMesh->mBitangents,
+                        pcMesh->mNumVertices * sizeof(aiVector3D));
+                }
+            }
+            else
+            {
+                // copy positions, transform them to worldspace
+                for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
+                    pcMeshOut->mVertices[aiCurrent[AI_PTVS_VERTEX]+n] = pcNode->mTransformation * pcMesh->mVertices[n];
+                }
+                aiMatrix4x4 mWorldIT = pcNode->mTransformation;
+                mWorldIT.Inverse().Transpose();
+
+                // TODO: implement Inverse() for aiMatrix3x3
+                aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
+
+                if (iVFormat & 0x2)
+                {
+                    // copy normals, transform them to worldspace
+                    for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
+                        pcMeshOut->mNormals[aiCurrent[AI_PTVS_VERTEX]+n] =
+                            (m * pcMesh->mNormals[n]).Normalize();
+                    }
+                }
+                if (iVFormat & 0x4)
+                {
+                    // copy tangents and bitangents, transform them to worldspace
+                    for (unsigned int n = 0; n < pcMesh->mNumVertices;++n)  {
+                        pcMeshOut->mTangents  [aiCurrent[AI_PTVS_VERTEX]+n] = (m * pcMesh->mTangents[n]).Normalize();
+                        pcMeshOut->mBitangents[aiCurrent[AI_PTVS_VERTEX]+n] = (m * pcMesh->mBitangents[n]).Normalize();
+                    }
+                }
+            }
+            unsigned int p = 0;
+            while (iVFormat & (0x100 << p))
+            {
+                // copy texture coordinates
+                memcpy(pcMeshOut->mTextureCoords[p] + aiCurrent[AI_PTVS_VERTEX],
+                    pcMesh->mTextureCoords[p],
+                    pcMesh->mNumVertices * sizeof(aiVector3D));
+                ++p;
+            }
+            p = 0;
+            while (iVFormat & (0x1000000 << p))
+            {
+                // copy vertex colors
+                memcpy(pcMeshOut->mColors[p] + aiCurrent[AI_PTVS_VERTEX],
+                    pcMesh->mColors[p],
+                    pcMesh->mNumVertices * sizeof(aiColor4D));
+                ++p;
+            }
+            // now we need to copy all faces. since we will delete the source mesh afterwards,
+            // we don't need to reallocate the array of indices except if this mesh is
+            // referenced multiple times.
+            for (unsigned int planck = 0;planck < pcMesh->mNumFaces;++planck)
+            {
+                aiFace& f_src = pcMesh->mFaces[planck];
+                aiFace& f_dst = pcMeshOut->mFaces[aiCurrent[AI_PTVS_FACE]+planck];
+
+                const unsigned int num_idx = f_src.mNumIndices;
+
+                f_dst.mNumIndices = num_idx;
+
+                unsigned int* pi;
+                if (!num_ref) { /* if last time the mesh is referenced -> no reallocation */
+                    pi = f_dst.mIndices = f_src.mIndices;
+
+                    // offset all vertex indices
+                    for (unsigned int hahn = 0; hahn < num_idx;++hahn){
+                        pi[hahn] += aiCurrent[AI_PTVS_VERTEX];
+                    }
+                }
+                else {
+                    pi = f_dst.mIndices = new unsigned int[num_idx];
+
+                    // copy and offset all vertex indices
+                    for (unsigned int hahn = 0; hahn < num_idx;++hahn){
+                        pi[hahn] = f_src.mIndices[hahn] + aiCurrent[AI_PTVS_VERTEX];
+                    }
+                }
+
+                // Update the mPrimitiveTypes member of the mesh
+                switch (pcMesh->mFaces[planck].mNumIndices)
+                {
+                case 0x1:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POINT;
+                    break;
+                case 0x2:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_LINE;
+                    break;
+                case 0x3:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
+                    break;
+                default:
+                    pcMeshOut->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
+                    break;
+                };
+            }
+            aiCurrent[AI_PTVS_VERTEX] += pcMesh->mNumVertices;
+            aiCurrent[AI_PTVS_FACE]   += pcMesh->mNumFaces;
+        }
+    }
+
+    // append all children of us
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i) {
+        CollectData(pcScene,pcNode->mChildren[i],iMat,
+            iVFormat,pcMeshOut,aiCurrent,num_refs);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Get a list of all vertex formats that occur for a given material index
 // The output list contains duplicate elements
-void PretransformVertices::GetVFormatList(const aiScene *pcScene, unsigned int iMat,
-		std::list<unsigned int> &aiOut) const {
-	for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
-		aiMesh *pcMesh = pcScene->mMeshes[i];
-		if (iMat == pcMesh->mMaterialIndex) {
-			aiOut.push_back(GetMeshVFormat(pcMesh));
-		}
-	}
+void PretransformVertices::GetVFormatList( aiScene* pcScene, unsigned int iMat,
+    std::list<unsigned int>& aiOut)
+{
+    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)
+    {
+        aiMesh* pcMesh = pcScene->mMeshes[ i ];
+        if (iMat == pcMesh->mMaterialIndex) {
+            aiOut.push_back(GetMeshVFormat(pcMesh));
+        }
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Compute the absolute transformation matrices of each node
-void PretransformVertices::ComputeAbsoluteTransform(aiNode *pcNode) {
-	if (pcNode->mParent) {
-		pcNode->mTransformation = pcNode->mParent->mTransformation * pcNode->mTransformation;
-	}
-
-	for (unsigned int i = 0; i < pcNode->mNumChildren; ++i) {
-		ComputeAbsoluteTransform(pcNode->mChildren[i]);
-	}
+void PretransformVertices::ComputeAbsoluteTransform( aiNode* pcNode )
+{
+    if (pcNode->mParent)    {
+        pcNode->mTransformation = pcNode->mParent->mTransformation*pcNode->mTransformation;
+    }
+
+    for (unsigned int i = 0;i < pcNode->mNumChildren;++i)   {
+        ComputeAbsoluteTransform(pcNode->mChildren[i]);
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Apply the node transformation to a mesh
-void PretransformVertices::ApplyTransform(aiMesh *mesh, const aiMatrix4x4 &mat) const {
-	// Check whether we need to transform the coordinates at all
-	if (!mat.IsIdentity()) {
-
-		// Check for odd negative scale (mirror)
-		if (mesh->HasFaces() && mat.Determinant() < 0) {
-			// Reverse the mesh face winding order
-			FlipWindingOrderProcess::ProcessMesh(mesh);
-		}
-
-		// Update positions
-		if (mesh->HasPositions()) {
-			for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-				mesh->mVertices[i] = mat * mesh->mVertices[i];
-			}
-		}
-
-		// Update normals and tangents
-		if (mesh->HasNormals() || mesh->HasTangentsAndBitangents()) {
-			const aiMatrix3x3 m = aiMatrix3x3(mat).Inverse().Transpose();
-
-			if (mesh->HasNormals()) {
-				for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-					mesh->mNormals[i] = (m * mesh->mNormals[i]).Normalize();
-				}
-			}
-			if (mesh->HasTangentsAndBitangents()) {
-				for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-					mesh->mTangents[i] = (m * mesh->mTangents[i]).Normalize();
-					mesh->mBitangents[i] = (m * mesh->mBitangents[i]).Normalize();
-				}
-			}
-		}
-	}
+void PretransformVertices::ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat)
+{
+    // Check whether we need to transform the coordinates at all
+    if (!mat.IsIdentity()) {
+
+        if (mesh->HasPositions()) {
+            for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+                mesh->mVertices[i] = mat * mesh->mVertices[i];
+            }
+        }
+        if (mesh->HasNormals() || mesh->HasTangentsAndBitangents()) {
+            aiMatrix4x4 mWorldIT = mat;
+            mWorldIT.Inverse().Transpose();
+
+            // TODO: implement Inverse() for aiMatrix3x3
+            aiMatrix3x3 m = aiMatrix3x3(mWorldIT);
+
+            if (mesh->HasNormals()) {
+                for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+                    mesh->mNormals[i] = (m * mesh->mNormals[i]).Normalize();
+                }
+            }
+            if (mesh->HasTangentsAndBitangents()) {
+                for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+                    mesh->mTangents[i]   = (m * mesh->mTangents[i]).Normalize();
+                    mesh->mBitangents[i] = (m * mesh->mBitangents[i]).Normalize();
+                }
+            }
+        }
+    }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Simple routine to build meshes in worldspace, no further optimization
-void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh *> &out, aiMesh **in,
-		unsigned int numIn, aiNode *node) const {
-	// NOTE:
-	//  aiMesh::mNumBones store original source mesh, or UINT_MAX if not a copy
-	//  aiMesh::mBones store reference to abs. transform we multiplied with
-
-	// process meshes
-	for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
-		aiMesh *mesh = in[node->mMeshes[i]];
-
-		// check whether we can operate on this mesh
-		if (!mesh->mBones || *reinterpret_cast<aiMatrix4x4 *>(mesh->mBones) == node->mTransformation) {
-			// yes, we can.
-			mesh->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);
-			mesh->mNumBones = UINT_MAX;
-		} else {
-
-			// try to find us in the list of newly created meshes
-			for (unsigned int n = 0; n < out.size(); ++n) {
-				aiMesh *ctz = out[n];
-				if (ctz->mNumBones == node->mMeshes[i] && *reinterpret_cast<aiMatrix4x4 *>(ctz->mBones) == node->mTransformation) {
-
-					// ok, use this one. Update node mesh index
-					node->mMeshes[i] = numIn + n;
-				}
-			}
-			if (node->mMeshes[i] < numIn) {
-				// Worst case. Need to operate on a full copy of the mesh
-				ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
-				aiMesh *ntz;
-
-				const unsigned int tmp = mesh->mNumBones; //
-				mesh->mNumBones = 0;
-				SceneCombiner::Copy(&ntz, mesh);
-				mesh->mNumBones = tmp;
-
-				ntz->mNumBones = node->mMeshes[i];
-				ntz->mBones = reinterpret_cast<aiBone **>(&node->mTransformation);
-
-				out.push_back(ntz);
-
-				node->mMeshes[i] = static_cast<unsigned int>(numIn + out.size() - 1);
-			}
-		}
-	}
-
-	// call children
-	for (unsigned int i = 0; i < node->mNumChildren; ++i)
-		BuildWCSMeshes(out, in, numIn, node->mChildren[i]);
+void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in,
+    unsigned int numIn, aiNode* node)
+{
+    // NOTE:
+    //  aiMesh::mNumBones store original source mesh, or UINT_MAX if not a copy
+    //  aiMesh::mBones store reference to abs. transform we multiplied with
+
+    // process meshes
+    for (unsigned int i = 0; i < node->mNumMeshes;++i) {
+        aiMesh* mesh = in[node->mMeshes[i]];
+
+        // check whether we can operate on this mesh
+        if (!mesh->mBones || *reinterpret_cast<aiMatrix4x4*>(mesh->mBones) == node->mTransformation) {
+            // yes, we can.
+            mesh->mBones = reinterpret_cast<aiBone**> (&node->mTransformation);
+            mesh->mNumBones = UINT_MAX;
+        }
+        else {
+
+            // try to find us in the list of newly created meshes
+            for (unsigned int n = 0; n < out.size(); ++n) {
+                aiMesh* ctz = out[n];
+                if (ctz->mNumBones == node->mMeshes[i] && *reinterpret_cast<aiMatrix4x4*>(ctz->mBones) ==  node->mTransformation) {
+
+                    // ok, use this one. Update node mesh index
+                    node->mMeshes[i] = numIn + n;
+                }
+            }
+            if (node->mMeshes[i] < numIn) {
+                // Worst case. Need to operate on a full copy of the mesh
+                ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
+                aiMesh* ntz;
+
+                const unsigned int tmp = mesh->mNumBones; //
+                mesh->mNumBones = 0;
+                SceneCombiner::Copy(&ntz,mesh);
+                mesh->mNumBones = tmp;
+
+                ntz->mNumBones = node->mMeshes[i];
+                ntz->mBones = reinterpret_cast<aiBone**> (&node->mTransformation);
+
+                out.push_back(ntz);
+
+                node->mMeshes[i] = static_cast<unsigned int>(numIn + out.size() - 1);
+            }
+        }
+    }
+
+    // call children
+    for (unsigned int i = 0; i < node->mNumChildren;++i)
+        BuildWCSMeshes(out,in,numIn,node->mChildren[i]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reset transformation matrices to identity
-void PretransformVertices::MakeIdentityTransform(aiNode *nd) const {
-	nd->mTransformation = aiMatrix4x4();
+void PretransformVertices::MakeIdentityTransform(aiNode* nd)
+{
+    nd->mTransformation = aiMatrix4x4();
 
-	// call children
-	for (unsigned int i = 0; i < nd->mNumChildren; ++i)
-		MakeIdentityTransform(nd->mChildren[i]);
+    // call children
+    for (unsigned int i = 0; i < nd->mNumChildren;++i)
+        MakeIdentityTransform(nd->mChildren[i]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build reference counters for all meshes
-void PretransformVertices::BuildMeshRefCountArray(const aiNode *nd, unsigned int *refs) const {
-	for (unsigned int i = 0; i < nd->mNumMeshes; ++i)
-		refs[nd->mMeshes[i]]++;
-
-	// call children
-	for (unsigned int i = 0; i < nd->mNumChildren; ++i)
-		BuildMeshRefCountArray(nd->mChildren[i], refs);
+void PretransformVertices::BuildMeshRefCountArray(aiNode* nd, unsigned int * refs)
+{
+    for (unsigned int i = 0; i< nd->mNumMeshes;++i)
+        refs[nd->mMeshes[i]]++;
+
+    // call children
+    for (unsigned int i = 0; i < nd->mNumChildren;++i)
+        BuildMeshRefCountArray(nd->mChildren[i],refs);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Executes the post processing step on the given imported data.
-void PretransformVertices::Execute(aiScene *pScene) {
-	ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
-
-	// Return immediately if we have no meshes
-	if (!pScene->mNumMeshes)
-		return;
-
-	const unsigned int iOldMeshes = pScene->mNumMeshes;
-	const unsigned int iOldAnimationChannels = pScene->mNumAnimations;
-	const unsigned int iOldNodes = CountNodes(pScene->mRootNode);
-
-	if (configTransform) {
-		pScene->mRootNode->mTransformation = configTransformation;
-	}
-
-	// first compute absolute transformation matrices for all nodes
-	ComputeAbsoluteTransform(pScene->mRootNode);
-
-	// Delete aiMesh::mBones for all meshes. The bones are
-	// removed during this step and we need the pointer as
-	// temporary storage
-	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-		aiMesh *mesh = pScene->mMeshes[i];
-
-		for (unsigned int a = 0; a < mesh->mNumBones; ++a)
-			delete mesh->mBones[a];
-
-		delete[] mesh->mBones;
-		mesh->mBones = NULL;
-	}
-
-	// now build a list of output meshes
-	std::vector<aiMesh *> apcOutMeshes;
-
-	// Keep scene hierarchy? It's an easy job in this case ...
-	// we go on and transform all meshes, if one is referenced by nodes
-	// with different absolute transformations a depth copy of the mesh
-	// is required.
-	if (configKeepHierarchy) {
-
-		// Hack: store the matrix we're transforming a mesh with in aiMesh::mBones
-		BuildWCSMeshes(apcOutMeshes, pScene->mMeshes, pScene->mNumMeshes, pScene->mRootNode);
-
-		// ... if new meshes have been generated, append them to the end of the scene
-		if (apcOutMeshes.size() > 0) {
-			aiMesh **npp = new aiMesh *[pScene->mNumMeshes + apcOutMeshes.size()];
-
-			memcpy(npp, pScene->mMeshes, sizeof(aiMesh *) * pScene->mNumMeshes);
-			memcpy(npp + pScene->mNumMeshes, &apcOutMeshes[0], sizeof(aiMesh *) * apcOutMeshes.size());
-
-			pScene->mNumMeshes += static_cast<unsigned int>(apcOutMeshes.size());
-			delete[] pScene->mMeshes;
-			pScene->mMeshes = npp;
-		}
-
-		// now iterate through all meshes and transform them to worldspace
-		for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-			ApplyTransform(pScene->mMeshes[i], *reinterpret_cast<aiMatrix4x4 *>(pScene->mMeshes[i]->mBones));
-
-			// prevent improper destruction
-			pScene->mMeshes[i]->mBones = NULL;
-			pScene->mMeshes[i]->mNumBones = 0;
-		}
-	} else {
-		apcOutMeshes.reserve(pScene->mNumMaterials << 1u);
-		std::list<unsigned int> aiVFormats;
-
-		std::vector<unsigned int> s(pScene->mNumMeshes, 0);
-		BuildMeshRefCountArray(pScene->mRootNode, &s[0]);
-
-		for (unsigned int i = 0; i < pScene->mNumMaterials; ++i) {
-			// get the list of all vertex formats for this material
-			aiVFormats.clear();
-			GetVFormatList(pScene, i, aiVFormats);
-			aiVFormats.sort();
-			aiVFormats.unique();
-			for (std::list<unsigned int>::const_iterator j = aiVFormats.begin(); j != aiVFormats.end(); ++j) {
-				unsigned int iVertices = 0;
-				unsigned int iFaces = 0;
-				CountVerticesAndFaces(pScene, pScene->mRootNode, i, *j, &iFaces, &iVertices);
-				if (0 != iFaces && 0 != iVertices) {
-					apcOutMeshes.push_back(new aiMesh());
-					aiMesh *pcMesh = apcOutMeshes.back();
-					pcMesh->mNumFaces = iFaces;
-					pcMesh->mNumVertices = iVertices;
-					pcMesh->mFaces = new aiFace[iFaces];
-					pcMesh->mVertices = new aiVector3D[iVertices];
-					pcMesh->mMaterialIndex = i;
-					if ((*j) & 0x2) pcMesh->mNormals = new aiVector3D[iVertices];
-					if ((*j) & 0x4) {
-						pcMesh->mTangents = new aiVector3D[iVertices];
-						pcMesh->mBitangents = new aiVector3D[iVertices];
-					}
-					iFaces = 0;
-					while ((*j) & (0x100 << iFaces)) {
-						pcMesh->mTextureCoords[iFaces] = new aiVector3D[iVertices];
-						if ((*j) & (0x10000 << iFaces))
-							pcMesh->mNumUVComponents[iFaces] = 3;
-						else
-							pcMesh->mNumUVComponents[iFaces] = 2;
-						iFaces++;
-					}
-					iFaces = 0;
-					while ((*j) & (0x1000000 << iFaces))
-						pcMesh->mColors[iFaces++] = new aiColor4D[iVertices];
-
-					// fill the mesh ...
-					unsigned int aiTemp[2] = { 0, 0 };
-					CollectData(pScene, pScene->mRootNode, i, *j, pcMesh, aiTemp, &s[0]);
-				}
-			}
-		}
-
-		// If no meshes are referenced in the node graph it is possible that we get no output meshes.
-		if (apcOutMeshes.empty()) {
-
-			throw DeadlyImportError("No output meshes: all meshes are orphaned and are not referenced by any nodes");
-		} else {
-			// now delete all meshes in the scene and build a new mesh list
-			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-				aiMesh *mesh = pScene->mMeshes[i];
-				mesh->mNumBones = 0;
-				mesh->mBones = NULL;
-
-				// we're reusing the face index arrays. avoid destruction
-				for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
-					mesh->mFaces[a].mNumIndices = 0;
-					mesh->mFaces[a].mIndices = NULL;
-				}
-
-				delete mesh;
-
-				// Invalidate the contents of the old mesh array. We will most
-				// likely have less output meshes now, so the last entries of
-				// the mesh array are not overridden. We set them to NULL to
-				// make sure the developer gets notified when his application
-				// attempts to access these fields ...
-				mesh = NULL;
-			}
-
-			// It is impossible that we have more output meshes than
-			// input meshes, so we can easily reuse the old mesh array
-			pScene->mNumMeshes = (unsigned int)apcOutMeshes.size();
-			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-				pScene->mMeshes[i] = apcOutMeshes[i];
-			}
-		}
-	}
-
-	// remove all animations from the scene
-	for (unsigned int i = 0; i < pScene->mNumAnimations; ++i)
-		delete pScene->mAnimations[i];
-	delete[] pScene->mAnimations;
-
-	pScene->mAnimations = NULL;
-	pScene->mNumAnimations = 0;
-
-	// --- we need to keep all cameras and lights
-	for (unsigned int i = 0; i < pScene->mNumCameras; ++i) {
-		aiCamera *cam = pScene->mCameras[i];
-		const aiNode *nd = pScene->mRootNode->FindNode(cam->mName);
-		ai_assert(NULL != nd);
-
-		// multiply all properties of the camera with the absolute
-		// transformation of the corresponding node
-		cam->mPosition = nd->mTransformation * cam->mPosition;
-		cam->mLookAt = aiMatrix3x3(nd->mTransformation) * cam->mLookAt;
-		cam->mUp = aiMatrix3x3(nd->mTransformation) * cam->mUp;
-	}
-
-	for (unsigned int i = 0; i < pScene->mNumLights; ++i) {
-		aiLight *l = pScene->mLights[i];
-		const aiNode *nd = pScene->mRootNode->FindNode(l->mName);
-		ai_assert(NULL != nd);
-
-		// multiply all properties of the camera with the absolute
-		// transformation of the corresponding node
-		l->mPosition = nd->mTransformation * l->mPosition;
-		l->mDirection = aiMatrix3x3(nd->mTransformation) * l->mDirection;
-		l->mUp = aiMatrix3x3(nd->mTransformation) * l->mUp;
-	}
-
-	if (!configKeepHierarchy) {
-
-		// now delete all nodes in the scene and build a new
-		// flat node graph with a root node and some level 1 children
-		aiNode *newRoot = new aiNode();
-		newRoot->mName = pScene->mRootNode->mName;
-		delete pScene->mRootNode;
-		pScene->mRootNode = newRoot;
-
-		if (1 == pScene->mNumMeshes && !pScene->mNumLights && !pScene->mNumCameras) {
-			pScene->mRootNode->mNumMeshes = 1;
-			pScene->mRootNode->mMeshes = new unsigned int[1];
-			pScene->mRootNode->mMeshes[0] = 0;
-		} else {
-			pScene->mRootNode->mNumChildren = pScene->mNumMeshes + pScene->mNumLights + pScene->mNumCameras;
-			aiNode **nodes = pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
-
-			// generate mesh nodes
-			for (unsigned int i = 0; i < pScene->mNumMeshes; ++i, ++nodes) {
-				aiNode *pcNode = new aiNode();
-				*nodes = pcNode;
-				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName = pScene->mMeshes[i]->mName;
-
-				// setup mesh indices
-				pcNode->mNumMeshes = 1;
-				pcNode->mMeshes = new unsigned int[1];
-				pcNode->mMeshes[0] = i;
-			}
-			// generate light nodes
-			for (unsigned int i = 0; i < pScene->mNumLights; ++i, ++nodes) {
-				aiNode *pcNode = new aiNode();
-				*nodes = pcNode;
-				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "light_%u", i);
-				pScene->mLights[i]->mName = pcNode->mName;
-			}
-			// generate camera nodes
-			for (unsigned int i = 0; i < pScene->mNumCameras; ++i, ++nodes) {
-				aiNode *pcNode = new aiNode();
-				*nodes = pcNode;
-				pcNode->mParent = pScene->mRootNode;
-				pcNode->mName.length = ::ai_snprintf(pcNode->mName.data, MAXLEN, "cam_%u", i);
-				pScene->mCameras[i]->mName = pcNode->mName;
-			}
-		}
-	} else {
-		// ... and finally set the transformation matrix of all nodes to identity
-		MakeIdentityTransform(pScene->mRootNode);
-	}
-
-	if (configNormalize) {
-		// compute the boundary of all meshes
-		aiVector3D min, max;
-		MinMaxChooser<aiVector3D>()(min, max);
-
-		for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-			aiMesh *m = pScene->mMeshes[a];
-			for (unsigned int i = 0; i < m->mNumVertices; ++i) {
-				min = std::min(m->mVertices[i], min);
-				max = std::max(m->mVertices[i], max);
-			}
-		}
-
-		// find the dominant axis
-		aiVector3D d = max - min;
-		const ai_real div = std::max(d.x, std::max(d.y, d.z)) * ai_real(0.5);
-
-		d = min + d * (ai_real)0.5;
-		for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-			aiMesh *m = pScene->mMeshes[a];
-			for (unsigned int i = 0; i < m->mNumVertices; ++i) {
-				m->mVertices[i] = (m->mVertices[i] - d) / div;
-			}
-		}
-	}
-
-	// print statistics
-	if (!DefaultLogger::isNullLogger()) {
-		ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
-
-		ASSIMP_LOG_INFO_F("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (",
-				CountNodes(pScene->mRootNode), " output nodes)");
-		ASSIMP_LOG_INFO_F("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras.");
-		ASSIMP_LOG_INFO_F("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
-	}
+void PretransformVertices::Execute( aiScene* pScene)
+{
+    ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
+
+    // Return immediately if we have no meshes
+    if (!pScene->mNumMeshes)
+        return;
+
+    const unsigned int iOldMeshes = pScene->mNumMeshes;
+    const unsigned int iOldAnimationChannels = pScene->mNumAnimations;
+    const unsigned int iOldNodes = CountNodes(pScene->mRootNode);
+
+    if(configTransform) {
+        pScene->mRootNode->mTransformation = configTransformation;
+    }
+
+    // first compute absolute transformation matrices for all nodes
+    ComputeAbsoluteTransform(pScene->mRootNode);
+
+    // Delete aiMesh::mBones for all meshes. The bones are
+    // removed during this step and we need the pointer as
+    // temporary storage
+    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)    {
+        aiMesh* mesh = pScene->mMeshes[i];
+
+        for (unsigned int a = 0; a < mesh->mNumBones;++a)
+            delete mesh->mBones[a];
+
+        delete[] mesh->mBones;
+        mesh->mBones = NULL;
+    }
+
+    // now build a list of output meshes
+    std::vector<aiMesh*> apcOutMeshes;
+
+    // Keep scene hierarchy? It's an easy job in this case ...
+    // we go on and transform all meshes, if one is referenced by nodes
+    // with different absolute transformations a depth copy of the mesh
+    // is required.
+    if( configKeepHierarchy ) {
+
+        // Hack: store the matrix we're transforming a mesh with in aiMesh::mBones
+        BuildWCSMeshes(apcOutMeshes,pScene->mMeshes,pScene->mNumMeshes, pScene->mRootNode);
+
+        // ... if new meshes have been generated, append them to the end of the scene
+        if (apcOutMeshes.size() > 0) {
+            aiMesh** npp = new aiMesh*[pScene->mNumMeshes + apcOutMeshes.size()];
+
+            memcpy(npp,pScene->mMeshes,sizeof(aiMesh*)*pScene->mNumMeshes);
+            memcpy(npp+pScene->mNumMeshes,&apcOutMeshes[0],sizeof(aiMesh*)*apcOutMeshes.size());
+
+            pScene->mNumMeshes  += static_cast<unsigned int>(apcOutMeshes.size());
+            delete[] pScene->mMeshes; pScene->mMeshes = npp;
+        }
+
+        // now iterate through all meshes and transform them to worldspace
+        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+            ApplyTransform(pScene->mMeshes[i],*reinterpret_cast<aiMatrix4x4*>( pScene->mMeshes[i]->mBones ));
+
+            // prevent improper destruction
+            pScene->mMeshes[i]->mBones    = NULL;
+            pScene->mMeshes[i]->mNumBones = 0;
+        }
+    } else {
+        apcOutMeshes.reserve(pScene->mNumMaterials<<1u);
+        std::list<unsigned int> aiVFormats;
+
+        std::vector<unsigned int> s(pScene->mNumMeshes,0);
+        BuildMeshRefCountArray(pScene->mRootNode,&s[0]);
+
+        for (unsigned int i = 0; i < pScene->mNumMaterials;++i)     {
+            // get the list of all vertex formats for this material
+            aiVFormats.clear();
+            GetVFormatList(pScene,i,aiVFormats);
+            aiVFormats.sort();
+            aiVFormats.unique();
+            for (std::list<unsigned int>::const_iterator j =  aiVFormats.begin();j != aiVFormats.end();++j) {
+                unsigned int iVertices = 0;
+                unsigned int iFaces = 0;
+                CountVerticesAndFaces(pScene,pScene->mRootNode,i,*j,&iFaces,&iVertices);
+                if (0 != iFaces && 0 != iVertices)
+                {
+                    apcOutMeshes.push_back(new aiMesh());
+                    aiMesh* pcMesh = apcOutMeshes.back();
+                    pcMesh->mNumFaces = iFaces;
+                    pcMesh->mNumVertices = iVertices;
+                    pcMesh->mFaces = new aiFace[iFaces];
+                    pcMesh->mVertices = new aiVector3D[iVertices];
+                    pcMesh->mMaterialIndex = i;
+                    if ((*j) & 0x2)pcMesh->mNormals = new aiVector3D[iVertices];
+                    if ((*j) & 0x4)
+                    {
+                        pcMesh->mTangents    = new aiVector3D[iVertices];
+                        pcMesh->mBitangents  = new aiVector3D[iVertices];
+                    }
+                    iFaces = 0;
+                    while ((*j) & (0x100 << iFaces))
+                    {
+                        pcMesh->mTextureCoords[iFaces] = new aiVector3D[iVertices];
+                        if ((*j) & (0x10000 << iFaces))pcMesh->mNumUVComponents[iFaces] = 3;
+                        else pcMesh->mNumUVComponents[iFaces] = 2;
+                        iFaces++;
+                    }
+                    iFaces = 0;
+                    while ((*j) & (0x1000000 << iFaces))
+                        pcMesh->mColors[iFaces++] = new aiColor4D[iVertices];
+
+                    // fill the mesh ...
+                    unsigned int aiTemp[2] = {0,0};
+                    CollectData(pScene,pScene->mRootNode,i,*j,pcMesh,aiTemp,&s[0]);
+                }
+            }
+        }
+
+        // If no meshes are referenced in the node graph it is possible that we get no output meshes.
+        if (apcOutMeshes.empty()) {
+            
+            throw DeadlyImportError("No output meshes: all meshes are orphaned and are not referenced by any nodes");
+        }
+        else
+        {
+            // now delete all meshes in the scene and build a new mesh list
+            for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
+            {
+                aiMesh* mesh = pScene->mMeshes[i];
+                mesh->mNumBones = 0;
+                mesh->mBones    = NULL;
+
+                // we're reusing the face index arrays. avoid destruction
+                for (unsigned int a = 0; a < mesh->mNumFaces; ++a) {
+                    mesh->mFaces[a].mNumIndices = 0;
+                    mesh->mFaces[a].mIndices = NULL;
+                }
+
+                delete mesh;
+
+                // Invalidate the contents of the old mesh array. We will most
+                // likely have less output meshes now, so the last entries of
+                // the mesh array are not overridden. We set them to NULL to
+                // make sure the developer gets notified when his application
+                // attempts to access these fields ...
+                mesh = NULL;
+            }
+
+            // It is impossible that we have more output meshes than
+            // input meshes, so we can easily reuse the old mesh array
+            pScene->mNumMeshes = (unsigned int)apcOutMeshes.size();
+            for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
+                pScene->mMeshes[i] = apcOutMeshes[i];
+            }
+        }
+    }
+
+    // remove all animations from the scene
+    for (unsigned int i = 0; i < pScene->mNumAnimations;++i)
+        delete pScene->mAnimations[i];
+    delete[] pScene->mAnimations;
+
+    pScene->mAnimations    = NULL;
+    pScene->mNumAnimations = 0;
+
+    // --- we need to keep all cameras and lights
+    for (unsigned int i = 0; i < pScene->mNumCameras;++i)
+    {
+        aiCamera* cam = pScene->mCameras[i];
+        const aiNode* nd = pScene->mRootNode->FindNode(cam->mName);
+        ai_assert(NULL != nd);
+
+        // multiply all properties of the camera with the absolute
+        // transformation of the corresponding node
+        cam->mPosition = nd->mTransformation * cam->mPosition;
+        cam->mLookAt   = aiMatrix3x3( nd->mTransformation ) * cam->mLookAt;
+        cam->mUp       = aiMatrix3x3( nd->mTransformation ) * cam->mUp;
+    }
+
+    for (unsigned int i = 0; i < pScene->mNumLights;++i)
+    {
+        aiLight* l = pScene->mLights[i];
+        const aiNode* nd = pScene->mRootNode->FindNode(l->mName);
+        ai_assert(NULL != nd);
+
+        // multiply all properties of the camera with the absolute
+        // transformation of the corresponding node
+        l->mPosition   = nd->mTransformation * l->mPosition;
+        l->mDirection  = aiMatrix3x3( nd->mTransformation ) * l->mDirection;
+        l->mUp         = aiMatrix3x3( nd->mTransformation ) * l->mUp;
+    }
+
+    if( !configKeepHierarchy ) {
+
+        // now delete all nodes in the scene and build a new
+        // flat node graph with a root node and some level 1 children
+        aiNode* newRoot = new aiNode();
+        newRoot->mName = pScene->mRootNode->mName;
+        delete pScene->mRootNode;
+        pScene->mRootNode = newRoot;
+
+        if (1 == pScene->mNumMeshes && !pScene->mNumLights && !pScene->mNumCameras)
+        {
+            pScene->mRootNode->mNumMeshes = 1;
+            pScene->mRootNode->mMeshes = new unsigned int[1];
+            pScene->mRootNode->mMeshes[0] = 0;
+        }
+        else
+        {
+            pScene->mRootNode->mNumChildren = pScene->mNumMeshes+pScene->mNumLights+pScene->mNumCameras;
+            aiNode** nodes = pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
+
+            // generate mesh nodes
+            for (unsigned int i = 0; i < pScene->mNumMeshes;++i,++nodes)
+            {
+                aiNode* pcNode = new aiNode();
+                *nodes = pcNode;
+                pcNode->mParent = pScene->mRootNode;
+                pcNode->mName = pScene->mMeshes[i]->mName;
+
+                // setup mesh indices
+                pcNode->mNumMeshes = 1;
+                pcNode->mMeshes = new unsigned int[1];
+                pcNode->mMeshes[0] = i;
+            }
+            // generate light nodes
+            for (unsigned int i = 0; i < pScene->mNumLights;++i,++nodes)
+            {
+                aiNode* pcNode = new aiNode();
+                *nodes = pcNode;
+                pcNode->mParent = pScene->mRootNode;
+                pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "light_%u",i);
+                pScene->mLights[i]->mName = pcNode->mName;
+            }
+            // generate camera nodes
+            for (unsigned int i = 0; i < pScene->mNumCameras;++i,++nodes)
+            {
+                aiNode* pcNode = new aiNode();
+                *nodes = pcNode;
+                pcNode->mParent = pScene->mRootNode;
+                pcNode->mName.length = ::ai_snprintf(pcNode->mName.data,MAXLEN,"cam_%u",i);
+                pScene->mCameras[i]->mName = pcNode->mName;
+            }
+        }
+    }
+    else {
+        // ... and finally set the transformation matrix of all nodes to identity
+        MakeIdentityTransform(pScene->mRootNode);
+    }
+
+    if (configNormalize) {
+        // compute the boundary of all meshes
+        aiVector3D min,max;
+        MinMaxChooser<aiVector3D> ()(min,max);
+
+        for (unsigned int a = 0; a <  pScene->mNumMeshes; ++a) {
+            aiMesh* m = pScene->mMeshes[a];
+            for (unsigned int i = 0; i < m->mNumVertices;++i) {
+                min = std::min(m->mVertices[i],min);
+                max = std::max(m->mVertices[i],max);
+            }
+        }
+
+        // find the dominant axis
+        aiVector3D d = max-min;
+        const ai_real div = std::max(d.x,std::max(d.y,d.z))*ai_real( 0.5);
+
+        d = min + d * (ai_real)0.5;
+        for (unsigned int a = 0; a <  pScene->mNumMeshes; ++a) {
+            aiMesh* m = pScene->mMeshes[a];
+            for (unsigned int i = 0; i < m->mNumVertices;++i) {
+                m->mVertices[i] = (m->mVertices[i]-d)/div;
+            }
+        }
+    }
+
+    // print statistics
+    if (!DefaultLogger::isNullLogger()) {
+        ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
+
+        ASSIMP_LOG_INFO_F("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (", 
+            CountNodes(pScene->mRootNode) ," output nodes)" );
+        ASSIMP_LOG_INFO_F("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras." );
+        ASSIMP_LOG_INFO_F("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
+    }
 }
diff --git a/thirdparty/assimp/code/PostProcessing/PretransformVertices.h b/thirdparty/assimp/code/PostProcessing/PretransformVertices.h
index 4a958def4e..b2982951e0 100644
--- a/thirdparty/assimp/code/PostProcessing/PretransformVertices.h
+++ b/thirdparty/assimp/code/PostProcessing/PretransformVertices.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -59,7 +59,7 @@ struct aiNode;
 
 class PretransformVerticesTest;
 
-namespace Assimp {
+namespace Assimp    {
 
 // ---------------------------------------------------------------------------
 /** The PretransformVertices pre-transforms all vertices in the node tree
@@ -68,97 +68,97 @@ namespace Assimp {
 */
 class ASSIMP_API PretransformVertices : public BaseProcess {
 public:
-	PretransformVertices();
-	~PretransformVertices();
+    PretransformVertices ();
+    ~PretransformVertices ();
 
-	// -------------------------------------------------------------------
-	// Check whether step is active
-	bool IsActive(unsigned int pFlags) const override;
+    // -------------------------------------------------------------------
+    // Check whether step is active
+    bool IsActive( unsigned int pFlags) const;
 
-	// -------------------------------------------------------------------
-	// Execute step on a given scene
-	void Execute(aiScene *pScene) override;
+    // -------------------------------------------------------------------
+    // Execute step on a given scene
+    void Execute( aiScene* pScene);
 
-	// -------------------------------------------------------------------
-	// Setup import settings
-	void SetupProperties(const Importer *pImp) override;
+    // -------------------------------------------------------------------
+    // Setup import settings
+    void SetupProperties(const Importer* pImp);
 
-	// -------------------------------------------------------------------
-	/** @brief Toggle the 'keep hierarchy' option
+    // -------------------------------------------------------------------
+    /** @brief Toggle the 'keep hierarchy' option
      *  @param keep    true for keep configuration.
      */
-	void KeepHierarchy(bool keep) {
-		configKeepHierarchy = keep;
-	}
+    void KeepHierarchy(bool keep) {
+        configKeepHierarchy = keep;
+    }
 
-	// -------------------------------------------------------------------
-	/** @brief Check whether 'keep hierarchy' is currently enabled.
+    // -------------------------------------------------------------------
+    /** @brief Check whether 'keep hierarchy' is currently enabled.
      *  @return ...
      */
-	bool IsHierarchyKept() const {
-		return configKeepHierarchy;
-	}
+    bool IsHierarchyKept() const {
+        return configKeepHierarchy;
+    }
 
 private:
-	// -------------------------------------------------------------------
-	// Count the number of nodes
-	unsigned int CountNodes(const aiNode *pcNode) const;
-
-	// -------------------------------------------------------------------
-	// Get a bitwise combination identifying the vertex format of a mesh
-	unsigned int GetMeshVFormat(aiMesh *pcMesh) const;
-
-	// -------------------------------------------------------------------
-	// Count the number of vertices in the whole scene and a given
-	// material index
-	void CountVerticesAndFaces(const aiScene *pcScene, const aiNode *pcNode,
-			unsigned int iMat,
-			unsigned int iVFormat,
-			unsigned int *piFaces,
-			unsigned int *piVertices) const;
-
-	// -------------------------------------------------------------------
-	// Collect vertex/face data
-	void CollectData(const aiScene *pcScene, const aiNode *pcNode,
-			unsigned int iMat,
-			unsigned int iVFormat,
-			aiMesh *pcMeshOut,
-			unsigned int aiCurrent[2],
-			unsigned int *num_refs) const;
-
-	// -------------------------------------------------------------------
-	// Get a list of all vertex formats that occur for a given material
-	// The output list contains duplicate elements
-	void GetVFormatList(const aiScene *pcScene, unsigned int iMat,
-			std::list<unsigned int> &aiOut) const;
-
-	// -------------------------------------------------------------------
-	// Compute the absolute transformation matrices of each node
-	void ComputeAbsoluteTransform(aiNode *pcNode);
-
-	// -------------------------------------------------------------------
-	// Simple routine to build meshes in worldspace, no further optimization
-	void BuildWCSMeshes(std::vector<aiMesh *> &out, aiMesh **in,
-			unsigned int numIn, aiNode *node) const;
-
-	// -------------------------------------------------------------------
-	// Apply the node transformation to a mesh
-	void ApplyTransform(aiMesh *mesh, const aiMatrix4x4 &mat) const;
-
-	// -------------------------------------------------------------------
-	// Reset transformation matrices to identity
-	void MakeIdentityTransform(aiNode *nd) const;
-
-	// -------------------------------------------------------------------
-	// Build reference counters for all meshes
-	void BuildMeshRefCountArray(const aiNode *nd, unsigned int *refs) const;
-
-	//! Configuration option: keep scene hierarchy as long as possible
-	bool configKeepHierarchy;
-	bool configNormalize;
-	bool configTransform;
-	aiMatrix4x4 configTransformation;
-	bool mConfigPointCloud;
+    // -------------------------------------------------------------------
+    // Count the number of nodes
+    unsigned int CountNodes( aiNode* pcNode );
+
+    // -------------------------------------------------------------------
+    // Get a bitwise combination identifying the vertex format of a mesh
+    unsigned int GetMeshVFormat(aiMesh* pcMesh);
+
+    // -------------------------------------------------------------------
+    // Count the number of vertices in the whole scene and a given
+    // material index
+    void CountVerticesAndFaces( aiScene* pcScene, aiNode* pcNode,
+        unsigned int iMat,
+        unsigned int iVFormat,
+        unsigned int* piFaces,
+        unsigned int* piVertices);
+
+    // -------------------------------------------------------------------
+    // Collect vertex/face data
+    void CollectData( aiScene* pcScene, aiNode* pcNode,
+        unsigned int iMat,
+        unsigned int iVFormat,
+        aiMesh* pcMeshOut,
+        unsigned int aiCurrent[2],
+        unsigned int* num_refs);
+
+    // -------------------------------------------------------------------
+    // Get a list of all vertex formats that occur for a given material
+    // The output list contains duplicate elements
+    void GetVFormatList( aiScene* pcScene, unsigned int iMat,
+        std::list<unsigned int>& aiOut);
+
+    // -------------------------------------------------------------------
+    // Compute the absolute transformation matrices of each node
+    void ComputeAbsoluteTransform( aiNode* pcNode );
+
+    // -------------------------------------------------------------------
+    // Simple routine to build meshes in worldspace, no further optimization
+    void BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in,
+        unsigned int numIn, aiNode* node);
+
+    // -------------------------------------------------------------------
+    // Apply the node transformation to a mesh
+    void ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat);
+
+    // -------------------------------------------------------------------
+    // Reset transformation matrices to identity
+    void MakeIdentityTransform(aiNode* nd);
+
+    // -------------------------------------------------------------------
+    // Build reference counters for all meshes
+    void BuildMeshRefCountArray(aiNode* nd, unsigned int * refs);
+
+    //! Configuration option: keep scene hierarchy as long as possible
+    bool configKeepHierarchy;
+    bool configNormalize;
+    bool configTransform;
+    aiMatrix4x4 configTransformation;
+    bool mConfigPointCloud;
 };
 
 } // end of namespace Assimp
diff --git a/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp b/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp
index 1239864381..59869fdff7 100644
--- a/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -230,6 +230,46 @@ VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh)
     return avPerVertexWeights;
 }
 
+
+// -------------------------------------------------------------------------------
+const char* TextureTypeToString(aiTextureType in)
+{
+    switch (in)
+    {
+    case aiTextureType_NONE:
+        return "n/a";
+    case aiTextureType_DIFFUSE:
+        return "Diffuse";
+    case aiTextureType_SPECULAR:
+        return "Specular";
+    case aiTextureType_AMBIENT:
+        return "Ambient";
+    case aiTextureType_EMISSIVE:
+        return "Emissive";
+    case aiTextureType_OPACITY:
+        return "Opacity";
+    case aiTextureType_NORMALS:
+        return "Normals";
+    case aiTextureType_HEIGHT:
+        return "Height";
+    case aiTextureType_SHININESS:
+        return "Shininess";
+    case aiTextureType_DISPLACEMENT:
+        return "Displacement";
+    case aiTextureType_LIGHTMAP:
+        return "Lightmap";
+    case aiTextureType_REFLECTION:
+        return "Reflection";
+    case aiTextureType_UNKNOWN:
+        return "Unknown";
+    default:
+        break;
+    }
+
+    ai_assert(false);
+    return  "BUG";
+}
+
 // -------------------------------------------------------------------------------
 const char* MappingTypeToString(aiTextureMapping in)
 {
diff --git a/thirdparty/assimp/code/PostProcessing/ProcessHelper.h b/thirdparty/assimp/code/PostProcessing/ProcessHelper.h
index 5762fbb35d..0afcc41420 100644
--- a/thirdparty/assimp/code/PostProcessing/ProcessHelper.h
+++ b/thirdparty/assimp/code/PostProcessing/ProcessHelper.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -316,6 +316,12 @@ typedef std::vector <PerVertexWeight> VertexWeightTable;
 // Compute a per-vertex bone weight table
 VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh);
 
+
+// -------------------------------------------------------------------------------
+// Get a string for a given aiTextureType
+const char* TextureTypeToString(aiTextureType in);
+
+
 // -------------------------------------------------------------------------------
 // Get a string for a given aiTextureMapping
 const char* MappingTypeToString(aiTextureMapping in);
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp b/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
index 0c42804103..49ec8f5c47 100644
--- a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
+++ b/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h b/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h
index 4b4f346c86..1f32a0abfb 100644
--- a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h
+++ b/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp b/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp
index 5ff5b55fad..99fd47a3aa 100644
--- a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h b/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h
index 458b37ee0d..7bb21a8330 100644
--- a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp b/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp
index 66714928b6..ac770c41f2 100644
--- a/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ScaleProcess.h b/thirdparty/assimp/code/PostProcessing/ScaleProcess.h
index 9cc664c6a7..468a216736 100644
--- a/thirdparty/assimp/code/PostProcessing/ScaleProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/ScaleProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp b/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp
index c1b08c5a78..be8405a17b 100644
--- a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
diff --git a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h b/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h
index 5135139edf..1d7ccfc152 100644
--- a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp b/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp
index 70960f4a89..1797b28d5a 100644
--- a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp
+++ b/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h b/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h
index fa6f77b2d8..3f90576ea9 100644
--- a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h
+++ b/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp b/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp
index bf60e2970f..8ae2ba7218 100644
--- a/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp
+++ b/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
@@ -92,8 +92,9 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
      *  are applied is - as always - scaling, rotation, translation.
      */
 
-	int rounded;
-	char szTemp[512];
+    char szTemp[512];
+    int rounded = 0;
+
 
     /* Optimize the rotation angle. That's slightly difficult as
      * we have an inprecise floating-point number (when comparing
@@ -184,6 +185,7 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
             info.mTranslation.y = out;
         }
     }
+    return;
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -426,7 +428,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
         // at the end of the list
         bool ref[AI_MAX_NUMBER_OF_TEXTURECOORDS];
         for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-            ref[n] = !mesh->mTextureCoords[n];
+            ref[n] = (!mesh->mTextureCoords[n] ? true : false);
 
         for (it = trafo.begin();it != trafo.end(); ++it)
             ref[(*it).uvIndex] = true;
diff --git a/thirdparty/assimp/code/PostProcessing/TextureTransform.h b/thirdparty/assimp/code/PostProcessing/TextureTransform.h
index 2f6fc3edc2..2a5d623d7f 100644
--- a/thirdparty/assimp/code/PostProcessing/TextureTransform.h
+++ b/thirdparty/assimp/code/PostProcessing/TextureTransform.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp b/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp
index 64cc63bbd1..1040836bbe 100644
--- a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp
+++ b/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 All rights reserved.
 
diff --git a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h b/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h
index 388952eb55..916b5103dd 100644
--- a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h
+++ b/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.
diff --git a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp b/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp
index 6212bfb690..75d1b6ef78 100644
--- a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp
+++ b/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp
@@ -3,7 +3,7 @@
 Open Asset Import Library (assimp)
 ---------------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 
@@ -603,18 +603,15 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
         ReportError("%s #%i is set, but there are only %i %s textures",
             szType,iIndex,iNumIndices,szType);
     }
-	if (!iNumIndices) {
-		return;
-	}
+    if (!iNumIndices)return;
     std::vector<aiTextureMapping> mappings(iNumIndices);
 
     // Now check whether all UV indices are valid ...
     bool bNoSpecified = true;
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i) {
+    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
+    {
         aiMaterialProperty* prop = pMaterial->mProperties[i];
-		if (prop->mSemantic != type) {
-			continue;
-		}
+        if (prop->mSemantic != type)continue;
 
         if ((int)prop->mIndex >= iNumIndices)
         {
@@ -637,7 +634,7 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
                 ReportError("Material property %s%i is expected to be 5 floats large (size is %i)",
                     prop->mKey.data,prop->mIndex, prop->mDataLength);
             }
-			//mappings[prop->mIndex] = ((aiUVTransform*)prop->mData);
+            mappings[prop->mIndex] = *((aiTextureMapping*)prop->mData);
         }
         else if (!::strcmp(prop->mKey.data,"$tex.uvwsrc")) {
             if (aiPTI_Integer != prop->mType || sizeof(int) > prop->mDataLength)
@@ -777,12 +774,6 @@ void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
     SearchForInvalidTextures(pMaterial,aiTextureType_DISPLACEMENT);
     SearchForInvalidTextures(pMaterial,aiTextureType_LIGHTMAP);
     SearchForInvalidTextures(pMaterial,aiTextureType_REFLECTION);
-    SearchForInvalidTextures(pMaterial,aiTextureType_BASE_COLOR);
-    SearchForInvalidTextures(pMaterial,aiTextureType_NORMAL_CAMERA);
-    SearchForInvalidTextures(pMaterial,aiTextureType_EMISSION_COLOR);
-    SearchForInvalidTextures(pMaterial,aiTextureType_METALNESS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_DIFFUSE_ROUGHNESS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_AMBIENT_OCCLUSION);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -804,7 +795,7 @@ void ValidateDSProcess::Validate( const aiTexture* pTexture)
         if (!pTexture->mWidth) {
             ReportError("aiTexture::mWidth is zero (compressed texture)");
         }
-        if ('\0' != pTexture->achFormatHint[HINTMAXTEXTURELEN - 1]) {
+        if ('\0' != pTexture->achFormatHint[3]) {
             ReportWarning("aiTexture::achFormatHint must be zero-terminated");
         }
         else if ('.'  == pTexture->achFormatHint[0])    {
diff --git a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h b/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h
index 4b5503ae03..7b309c9251 100644
--- a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h
+++ b/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h
@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2020, assimp team
+Copyright (c) 2006-2019, assimp team
 
 
 All rights reserved.