remove assimp pending fbx upgrade

60 files changed, 0 insertions, 14937 deletions

diff --git a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp b/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp
deleted file mode 100644
index 75daeb6b59..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.cpp
+++ /dev/null
@@ -1,268 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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"
-
-#include <assimp/BaseImporter.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <iostream>
-
-namespace Assimp {
-
-/// The default class constructor.
-ArmaturePopulate::ArmaturePopulate() : BaseProcess()
-{}
-
-/// The class destructor.
-ArmaturePopulate::~ArmaturePopulate() 
-{}
-
-bool ArmaturePopulate::IsActive(unsigned int pFlags) const {
-  return (pFlags & aiProcess_PopulateArmatureData) != 0;
-}
-
-void ArmaturePopulate::SetupProperties(const Importer *pImp) {
-  // 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);
-
-  BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
-
-  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 :)
-
-    // bone->mOffsetMatrix = bone_node->mTransformation;
-    aiNode *armature = GetArmatureRoot(bone_node, bones);
-
-    ai_assert(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;
-  }
-}
-
-
-/* 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 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);
-        }
-      }
-
-      // 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 */
-void ArmaturePopulate::BuildNodeList(const aiNode *current_node,
-                                     std::vector<aiNode *> &nodes) {
-  ai_assert(current_node);
-
-  for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-    aiNode *child = current_node->mChildren[nodeId];
-    ai_assert(child);
-
-    nodes.push_back(child);
-
-    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 :)
- */
-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;
-      }
-    }
-
-    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));
-  }
-}
-
-
-/* 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;
-  }
-  
-  ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
-  
-  return nullptr;
-}
-
-
-
-/* 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;
-    }
-  }
-
-  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 */
-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;
-    }
-  }
-
-  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;
-  }
-
-  // unique names can cause this problem
-  ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
-
-  return nullptr;
-}
-
-
-
-
-} // Namespace Assimp
diff --git a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h b/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h
deleted file mode 100644
index aa1ad7c80c..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ArmaturePopulate.h
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-#ifndef ARMATURE_POPULATE_H_
-#define ARMATURE_POPULATE_H_
-
-#include "Common/BaseProcess.h"
-#include <assimp/BaseImporter.h>
-#include <vector>
-#include <map>
-
-
-struct aiNode;
-struct aiBone;
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** Armature Populate: This is a post process designed
- * To save you time when importing models into your game engines
- * This was originally designed only for fbx but will work with other formats
- * it is intended to auto populate aiBone data with armature and the aiNode
- * This is very useful when dealing with skinned meshes
- * or when dealing with many different skeletons
- * It's off by default but recommend that you try it and use it
- * It should reduce down any glue code you have in your
- * importers
- * You can contact RevoluPowered <gordon@gordonite.tech>
- * For more info about this
-*/
-class ASSIMP_API ArmaturePopulate : public BaseProcess {
-public:
-    /// The default class constructor.
-    ArmaturePopulate();
-
-    /// The class destructor.
-    virtual ~ArmaturePopulate();
-
-    /// Overwritten, @see BaseProcess
-    virtual bool IsActive( unsigned int pFlags ) const;
-
-    /// Overwritten, @see BaseProcess
-    virtual void SetupProperties( const Importer* pImp );
-
-    /// Overwritten, @see BaseProcess
-    virtual void Execute( aiScene* pScene );
-
-    static aiNode *GetArmatureRoot(aiNode *bone_node,
-                                      std::vector<aiBone *> &bone_list);
-
-    static bool IsBoneNode(const aiString &bone_name,
-                              std::vector<aiBone *> &bones);
-
-    static aiNode *GetNodeFromStack(const aiString &node_name,
-                                       std::vector<aiNode *> &nodes);
-
-    static void BuildNodeList(const aiNode *current_node,
-                                 std::vector<aiNode *> &nodes);
-
-    static void BuildBoneList(aiNode *current_node, const aiNode *root_node,
-                                 const aiScene *scene,
-                                 std::vector<aiBone *> &bones);                        
-
-    static void 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);
-};
-
-} // Namespace Assimp
-
-
-#endif // SCALE_PROCESS_H_
\ No newline at end of file
diff --git a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp b/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp
deleted file mode 100644
index a3f7dd2557..0000000000
--- a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.cpp
+++ /dev/null
@@ -1,319 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to calculate
- *  tangents and bitangents for all imported meshes
- */
-
-// internal headers
-#include "CalcTangentsProcess.h"
-#include "ProcessHelper.h"
-#include <assimp/TinyFormatter.h>
-#include <assimp/qnan.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-CalcTangentsProcess::CalcTangentsProcess()
-: configMaxAngle( AI_DEG_TO_RAD(45.f) )
-, configSourceUV( 0 ) {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-CalcTangentsProcess::~CalcTangentsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool CalcTangentsProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_CalcTangentSpace) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void CalcTangentsProcess::SetupProperties(const Importer* pImp)
-{
-    ai_assert( NULL != pImp );
-
-    // get the current value of the property
-    configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_CT_MAX_SMOOTHING_ANGLE,45.f);
-    configMaxAngle = std::max(std::min(configMaxAngle,45.0f),0.0f);
-    configMaxAngle = AI_DEG_TO_RAD(configMaxAngle);
-
-    configSourceUV = pImp->GetPropertyInteger(AI_CONFIG_PP_CT_TEXTURE_CHANNEL_INDEX,0);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void CalcTangentsProcess::Execute( aiScene* pScene)
-{
-    ai_assert( NULL != pScene );
-
-    ASSIMP_LOG_DEBUG("CalcTangentsProcess begin");
-
-    bool bHas = false;
-    for ( unsigned int a = 0; a < pScene->mNumMeshes; a++ ) {
-        if(ProcessMesh( pScene->mMeshes[a],a))bHas = true;
-    }
-
-    if ( bHas ) {
-        ASSIMP_LOG_INFO("CalcTangentsProcess finished. Tangents have been calculated");
-    } else {
-        ASSIMP_LOG_DEBUG("CalcTangentsProcess finished");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Calculates tangents and bi-tangents for the given mesh
-bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
-{
-    // we assume that the mesh is still in the verbose vertex format where each face has its own set
-    // of vertices and no vertices are shared between faces. Sadly I don't know any quick test to
-    // assert() it here.
-    // assert( must be verbose, dammit);
-
-    if (pMesh->mTangents) // this implies that mBitangents is also there
-        return false;
-
-    // If the mesh consists of lines and/or points but not of
-    // triangles or higher-order polygons the normal vectors
-    // are undefined.
-    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))
-    {
-        ASSIMP_LOG_INFO("Tangents are undefined for line and point meshes");
-        return false;
-    }
-
-    // what we can check, though, is if the mesh has normals and texture coordinates. That's a requirement
-    if( pMesh->mNormals == NULL)
-    {
-        ASSIMP_LOG_ERROR("Failed to compute tangents; need normals");
-        return false;
-    }
-    if( configSourceUV >= AI_MAX_NUMBER_OF_TEXTURECOORDS || !pMesh->mTextureCoords[configSourceUV] )
-    {
-        ASSIMP_LOG_ERROR((Formatter::format("Failed to compute tangents; need UV data in channel"),configSourceUV));
-        return false;
-    }
-
-    const float angleEpsilon = 0.9999f;
-
-    std::vector<bool> vertexDone( pMesh->mNumVertices, false);
-    const float qnan = get_qnan();
-
-    // create space for the tangents and bitangents
-    pMesh->mTangents = new aiVector3D[pMesh->mNumVertices];
-    pMesh->mBitangents = new aiVector3D[pMesh->mNumVertices];
-
-    const aiVector3D* meshPos = pMesh->mVertices;
-    const aiVector3D* meshNorm = pMesh->mNormals;
-    const aiVector3D* meshTex = pMesh->mTextureCoords[configSourceUV];
-    aiVector3D* meshTang = pMesh->mTangents;
-    aiVector3D* meshBitang = pMesh->mBitangents;
-
-    // calculate the tangent and bitangent for every face
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        const aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices < 3)
-        {
-            // There are less than three indices, thus the tangent vector
-            // is not defined. We are finished with these vertices now,
-            // their tangent vectors are set to qnan.
-            for (unsigned int i = 0; i < face.mNumIndices;++i)
-            {
-                unsigned int idx = face.mIndices[i];
-                vertexDone  [idx] = true;
-                meshTang    [idx] = aiVector3D(qnan);
-                meshBitang  [idx] = aiVector3D(qnan);
-            }
-
-            continue;
-        }
-
-        // triangle or polygon... we always use only the first three indices. A polygon
-        // is supposed to be planar anyways....
-        // FIXME: (thom) create correct calculation for multi-vertex polygons maybe?
-        const unsigned int p0 = face.mIndices[0], p1 = face.mIndices[1], p2 = face.mIndices[2];
-
-        // position differences p1->p2 and p1->p3
-        aiVector3D v = meshPos[p1] - meshPos[p0], w = meshPos[p2] - meshPos[p0];
-
-        // texture offset p1->p2 and p1->p3
-        float sx = meshTex[p1].x - meshTex[p0].x, sy = meshTex[p1].y - meshTex[p0].y;
-        float tx = meshTex[p2].x - meshTex[p0].x, ty = meshTex[p2].y - meshTex[p0].y;
-        float dirCorrection = (tx * sy - ty * sx) < 0.0f ? -1.0f : 1.0f;
-        // when t1, t2, t3 in same position in UV space, just use default UV direction.
-        if (  sx * ty == sy * tx ) {
-            sx = 0.0; sy = 1.0;
-            tx = 1.0; ty = 0.0;
-        }
-
-        // tangent points in the direction where to positive X axis of the texture coord's would point in model space
-        // bitangent's points along the positive Y axis of the texture coord's, respectively
-        aiVector3D tangent, bitangent;
-        tangent.x = (w.x * sy - v.x * ty) * dirCorrection;
-        tangent.y = (w.y * sy - v.y * ty) * dirCorrection;
-        tangent.z = (w.z * sy - v.z * ty) * dirCorrection;
-        bitangent.x = (w.x * sx - v.x * tx) * dirCorrection;
-        bitangent.y = (w.y * sx - v.y * tx) * dirCorrection;
-        bitangent.z = (w.z * sx - v.z * tx) * dirCorrection;
-
-        // store for every vertex of that face
-        for( unsigned int b = 0; b < face.mNumIndices; ++b ) {
-            unsigned int p = face.mIndices[b];
-
-            // project tangent and bitangent into the plane formed by the vertex' normal
-            aiVector3D localTangent = tangent - meshNorm[p] * (tangent * meshNorm[p]);
-            aiVector3D localBitangent = bitangent - meshNorm[p] * (bitangent * meshNorm[p]);
-            localTangent.NormalizeSafe(); localBitangent.NormalizeSafe();
-
-            // reconstruct tangent/bitangent according to normal and bitangent/tangent when it's infinite or NaN.
-            bool invalid_tangent = is_special_float(localTangent.x) || is_special_float(localTangent.y) || is_special_float(localTangent.z);
-            bool invalid_bitangent = is_special_float(localBitangent.x) || is_special_float(localBitangent.y) || is_special_float(localBitangent.z);
-            if (invalid_tangent != invalid_bitangent) {
-                if (invalid_tangent) {
-                    localTangent = meshNorm[p] ^ localBitangent;
-                    localTangent.NormalizeSafe();
-                } else {
-                    localBitangent = localTangent ^ meshNorm[p];
-                    localBitangent.NormalizeSafe();
-                }
-            }
-
-            // and write it into the mesh.
-            meshTang[ p ]   = localTangent;
-            meshBitang[ p ] = localBitangent;
-        }
-    }
-
-
-    // create a helper to quickly find locally close vertices among the vertex array
-    // FIX: check whether we can reuse the SpatialSort of a previous step
-    SpatialSort* vertexFinder = NULL;
-    SpatialSort  _vertexFinder;
-    float posEpsilon;
-    if (shared)
-    {
-        std::vector<std::pair<SpatialSort,float> >* avf;
-        shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);
-        if (avf)
-        {
-            std::pair<SpatialSort,float>& blubb = avf->operator [] (meshIndex);
-            vertexFinder = &blubb.first;
-            posEpsilon = blubb.second;;
-        }
-    }
-    if (!vertexFinder)
-    {
-        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof( aiVector3D));
-        vertexFinder = &_vertexFinder;
-        posEpsilon = ComputePositionEpsilon(pMesh);
-    }
-    std::vector<unsigned int> verticesFound;
-
-    const float fLimit = std::cos(configMaxAngle);
-    std::vector<unsigned int> closeVertices;
-
-    // in the second pass we now smooth out all tangents and bitangents at the same local position
-    // if they are not too far off.
-    for( unsigned int a = 0; a < pMesh->mNumVertices; a++)
-    {
-        if( vertexDone[a])
-            continue;
-
-        const aiVector3D& origPos = pMesh->mVertices[a];
-        const aiVector3D& origNorm = pMesh->mNormals[a];
-        const aiVector3D& origTang = pMesh->mTangents[a];
-        const aiVector3D& origBitang = pMesh->mBitangents[a];
-        closeVertices.resize( 0 );
-
-        // find all vertices close to that position
-        vertexFinder->FindPositions( origPos, posEpsilon, verticesFound);
-
-        closeVertices.reserve (verticesFound.size()+5);
-        closeVertices.push_back( a);
-
-        // look among them for other vertices sharing the same normal and a close-enough tangent/bitangent
-        for( unsigned int b = 0; b < verticesFound.size(); b++)
-        {
-            unsigned int idx = verticesFound[b];
-            if( vertexDone[idx])
-                continue;
-            if( meshNorm[idx] * origNorm < angleEpsilon)
-                continue;
-            if(  meshTang[idx] * origTang < fLimit)
-                continue;
-            if( meshBitang[idx] * origBitang < fLimit)
-                continue;
-
-            // it's similar enough -> add it to the smoothing group
-            closeVertices.push_back( idx);
-            vertexDone[idx] = true;
-        }
-
-        // smooth the tangents and bitangents of all vertices that were found to be close enough
-        aiVector3D smoothTangent( 0, 0, 0), smoothBitangent( 0, 0, 0);
-        for( unsigned int b = 0; b < closeVertices.size(); ++b)
-        {
-            smoothTangent += meshTang[ closeVertices[b] ];
-            smoothBitangent += meshBitang[ closeVertices[b] ];
-        }
-        smoothTangent.Normalize();
-        smoothBitangent.Normalize();
-
-        // and write it back into all affected tangents
-        for( unsigned int b = 0; b < closeVertices.size(); ++b)
-        {
-            meshTang[ closeVertices[b] ] = smoothTangent;
-            meshBitang[ closeVertices[b] ] = smoothBitangent;
-        }
-    }
-    return true;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h b/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h
deleted file mode 100644
index 3568a624f8..0000000000
--- a/thirdparty/assimp/code/PostProcessing/CalcTangentsProcess.h
+++ /dev/null
@@ -1,117 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-
-/** @file Defines a post processing step to calculate tangents and
-    bi-tangents on all imported meshes.*/
-#ifndef AI_CALCTANGENTSPROCESS_H_INC
-#define AI_CALCTANGENTSPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-struct aiMesh;
-
-namespace Assimp
-{
-
-// ---------------------------------------------------------------------------
-/** The CalcTangentsProcess calculates the tangent and bitangent for any vertex
- * of all meshes. It is expected to be run before the JoinVerticesProcess runs
- * because the joining of vertices also considers tangents and bitangents for
- * uniqueness.
- */
-class ASSIMP_API_WINONLY CalcTangentsProcess : public BaseProcess
-{
-public:
-
-    CalcTangentsProcess();
-    ~CalcTangentsProcess();
-
-public:
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag.
-    * @param pFlags The processing flags the importer was called with.
-    *   A bitwise combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields,
-    *   false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    void SetupProperties(const Importer* pImp);
-
-
-    // setter for configMaxAngle
-    inline void SetMaxSmoothAngle(float f)
-    {
-        configMaxAngle =f;
-    }
-
-protected:
-
-    // -------------------------------------------------------------------
-    /** Calculates tangents and bitangents for a specific mesh.
-    * @param pMesh The mesh to process.
-    * @param meshIndex Index of the mesh
-    */
-    bool ProcessMesh( aiMesh* pMesh, unsigned int meshIndex);
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-private:
-
-    /** Configuration option: maximum smoothing angle, in radians*/
-    float configMaxAngle;
-    unsigned int configSourceUV;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_CALCTANGENTSPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp b/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
deleted file mode 100644
index df4d44337d..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.cpp
+++ /dev/null
@@ -1,506 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file GenUVCoords step */
-
-
-#include "ComputeUVMappingProcess.h"
-#include "ProcessHelper.h"
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-
-namespace {
-
-    const static aiVector3D base_axis_y(0.0,1.0,0.0);
-    const static aiVector3D base_axis_x(1.0,0.0,0.0);
-    const static aiVector3D base_axis_z(0.0,0.0,1.0);
-    const static ai_real angle_epsilon = ai_real( 0.95 );
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-ComputeUVMappingProcess::ComputeUVMappingProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-ComputeUVMappingProcess::~ComputeUVMappingProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool ComputeUVMappingProcess::IsActive( unsigned int pFlags) const
-{
-    return  (pFlags & aiProcess_GenUVCoords) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Check whether a ray intersects a plane and find the intersection point
-inline bool PlaneIntersect(const aiRay& ray, const aiVector3D& planePos,
-    const aiVector3D& planeNormal, aiVector3D& pos)
-{
-    const ai_real b = planeNormal * (planePos - ray.pos);
-    ai_real h = ray.dir * planeNormal;
-    if ((h < 10e-5 && h > -10e-5) || (h = b/h) < 0)
-        return false;
-
-    pos = ray.pos + (ray.dir * h);
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Find the first empty UV channel in a mesh
-inline unsigned int FindEmptyUVChannel (aiMesh* mesh)
-{
-    for (unsigned int m = 0; m < AI_MAX_NUMBER_OF_TEXTURECOORDS;++m)
-        if (!mesh->mTextureCoords[m])return m;
-
-    ASSIMP_LOG_ERROR("Unable to compute UV coordinates, no free UV slot found");
-    return UINT_MAX;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Try to remove UV seams
-void RemoveUVSeams (aiMesh* mesh, aiVector3D* out)
-{
-    // TODO: just a very rough algorithm. I think it could be done
-    // much easier, but I don't know how and am currently too tired to
-    // to think about a better solution.
-
-    const static ai_real LOWER_LIMIT = ai_real( 0.1 );
-    const static ai_real UPPER_LIMIT = ai_real( 0.9 );
-
-    const static ai_real LOWER_EPSILON = ai_real( 10e-3 );
-    const static ai_real UPPER_EPSILON = ai_real( 1.0-10e-3 );
-
-    for (unsigned int fidx = 0; fidx < mesh->mNumFaces;++fidx)
-    {
-        const aiFace& face = mesh->mFaces[fidx];
-        if (face.mNumIndices < 3) continue; // triangles and polygons only, please
-
-        unsigned int small = face.mNumIndices, large = small;
-        bool zero = false, one = false, round_to_zero = false;
-
-        // Check whether this face lies on a UV seam. We can just guess,
-        // but the assumption that a face with at least one very small
-        // on the one side and one very large U coord on the other side
-        // lies on a UV seam should work for most cases.
-        for (unsigned int n = 0; n < face.mNumIndices;++n)
-        {
-            if (out[face.mIndices[n]].x < LOWER_LIMIT)
-            {
-                small = n;
-
-                // If we have a U value very close to 0 we can't
-                // round the others to 0, too.
-                if (out[face.mIndices[n]].x <= LOWER_EPSILON)
-                    zero = true;
-                else round_to_zero = true;
-            }
-            if (out[face.mIndices[n]].x > UPPER_LIMIT)
-            {
-                large = n;
-
-                // If we have a U value very close to 1 we can't
-                // round the others to 1, too.
-                if (out[face.mIndices[n]].x >= UPPER_EPSILON)
-                    one = true;
-            }
-        }
-        if (small != face.mNumIndices && large != face.mNumIndices)
-        {
-            for (unsigned int n = 0; n < face.mNumIndices;++n)
-            {
-                // If the u value is over the upper limit and no other u
-                // value of that face is 0, round it to 0
-                if (out[face.mIndices[n]].x > UPPER_LIMIT && !zero)
-                    out[face.mIndices[n]].x = 0.0;
-
-                // If the u value is below the lower limit and no other u
-                // value of that face is 1, round it to 1
-                else if (out[face.mIndices[n]].x < LOWER_LIMIT && !one)
-                    out[face.mIndices[n]].x = 1.0;
-
-                // The face contains both 0 and 1 as UV coords. This can occur
-                // for faces which have an edge that lies directly on the seam.
-                // Due to numerical inaccuracies one U coord becomes 0, the
-                // other 1. But we do still have a third UV coord to determine
-                // to which side we must round to.
-                else if (one && zero)
-                {
-                    if (round_to_zero && out[face.mIndices[n]].x >=  UPPER_EPSILON)
-                        out[face.mIndices[n]].x = 0.0;
-                    else if (!round_to_zero && out[face.mIndices[n]].x <= LOWER_EPSILON)
-                        out[face.mIndices[n]].x = 1.0;
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ComputeUVMappingProcess::ComputeSphereMapping(aiMesh* mesh,const aiVector3D& axis, aiVector3D* out)
-{
-    aiVector3D center, min, max;
-    FindMeshCenter(mesh, center, min, max);
-
-    // If the axis is one of x,y,z run a faster code path. It's worth the extra effort ...
-    // currently the mapping axis will always be one of x,y,z, except if the
-    // PretransformVertices step is used (it transforms the meshes into worldspace,
-    // thus changing the mapping axis)
-    if (axis * base_axis_x >= angle_epsilon)    {
-
-        // For each point get a normalized projection vector in the sphere,
-        // get its longitude and latitude and map them to their respective
-        // UV axes. Problems occur around the poles ... unsolvable.
-        //
-        // The spherical coordinate system looks like this:
-        // x = cos(lon)*cos(lat)
-        // y = sin(lon)*cos(lat)
-        // z = sin(lat)
-        //
-        // Thus we can derive:
-        // lat  = arcsin (z)
-        // lon  = arctan (y/x)
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize();
-            out[pnt] = aiVector3D((std::atan2(diff.z, diff.y) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
-                (std::asin  (diff.x) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
-        }
-    }
-    else if (axis * base_axis_y >= angle_epsilon)   {
-        // ... just the same again
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize();
-            out[pnt] = aiVector3D((std::atan2(diff.x, diff.z) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
-                (std::asin  (diff.y) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
-        }
-    }
-    else if (axis * base_axis_z >= angle_epsilon)   {
-        // ... just the same again
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D diff = (mesh->mVertices[pnt]-center).Normalize();
-            out[pnt] = aiVector3D((std::atan2(diff.y, diff.x) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
-                (std::asin  (diff.z) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
-        }
-    }
-    // slower code path in case the mapping axis is not one of the coordinate system axes
-    else    {
-        aiMatrix4x4 mTrafo;
-        aiMatrix4x4::FromToMatrix(axis,base_axis_y,mTrafo);
-
-        // again the same, except we're applying a transformation now
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D diff = ((mTrafo*mesh->mVertices[pnt])-center).Normalize();
-            out[pnt] = aiVector3D((std::atan2(diff.y, diff.x) + AI_MATH_PI_F ) / AI_MATH_TWO_PI_F,
-                (std::asin(diff.z) + AI_MATH_HALF_PI_F) / AI_MATH_PI_F, 0.0);
-        }
-    }
-
-
-    // Now find and remove UV seams. A seam occurs if a face has a tcoord
-    // close to zero on the one side, and a tcoord close to one on the
-    // other side.
-    RemoveUVSeams(mesh,out);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ComputeUVMappingProcess::ComputeCylinderMapping(aiMesh* mesh,const aiVector3D& axis, aiVector3D* out)
-{
-    aiVector3D center, min, max;
-
-    // If the axis is one of x,y,z run a faster code path. It's worth the extra effort ...
-    // currently the mapping axis will always be one of x,y,z, except if the
-    // PretransformVertices step is used (it transforms the meshes into worldspace,
-    // thus changing the mapping axis)
-    if (axis * base_axis_x >= angle_epsilon)    {
-        FindMeshCenter(mesh, center, min, max);
-        const ai_real diff = max.x - min.x;
-
-        // If the main axis is 'z', the z coordinate of a point 'p' is mapped
-        // directly to the texture V axis. The other axis is derived from
-        // the angle between ( p.x - c.x, p.y - c.y ) and (1,0), where
-        // 'c' is the center point of the mesh.
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D& pos = mesh->mVertices[pnt];
-            aiVector3D& uv  = out[pnt];
-
-            uv.y = (pos.x - min.x) / diff;
-            uv.x = (std::atan2( pos.z - center.z, pos.y - center.y) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
-        }
-    }
-    else if (axis * base_axis_y >= angle_epsilon)   {
-        FindMeshCenter(mesh, center, min, max);
-        const ai_real diff = max.y - min.y;
-
-        // just the same ...
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D& pos = mesh->mVertices[pnt];
-            aiVector3D& uv  = out[pnt];
-
-            uv.y = (pos.y - min.y) / diff;
-            uv.x = (std::atan2( pos.x - center.x, pos.z - center.z) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
-        }
-    }
-    else if (axis * base_axis_z >= angle_epsilon)   {
-        FindMeshCenter(mesh, center, min, max);
-        const ai_real diff = max.z - min.z;
-
-        // just the same ...
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D& pos = mesh->mVertices[pnt];
-            aiVector3D& uv  = out[pnt];
-
-            uv.y = (pos.z - min.z) / diff;
-            uv.x = (std::atan2( pos.y - center.y, pos.x - center.x) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
-        }
-    }
-    // slower code path in case the mapping axis is not one of the coordinate system axes
-    else {
-        aiMatrix4x4 mTrafo;
-        aiMatrix4x4::FromToMatrix(axis,base_axis_y,mTrafo);
-        FindMeshCenterTransformed(mesh, center, min, max,mTrafo);
-        const ai_real diff = max.y - min.y;
-
-        // again the same, except we're applying a transformation now
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt){
-            const aiVector3D pos = mTrafo* mesh->mVertices[pnt];
-            aiVector3D& uv  = out[pnt];
-
-            uv.y = (pos.y - min.y) / diff;
-            uv.x = (std::atan2( pos.x - center.x, pos.z - center.z) +(ai_real)AI_MATH_PI ) / (ai_real)AI_MATH_TWO_PI;
-        }
-    }
-
-    // Now find and remove UV seams. A seam occurs if a face has a tcoord
-    // close to zero on the one side, and a tcoord close to one on the
-    // other side.
-    RemoveUVSeams(mesh,out);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D& axis, aiVector3D* out)
-{
-    ai_real diffu,diffv;
-    aiVector3D center, min, max;
-
-    // If the axis is one of x,y,z run a faster code path. It's worth the extra effort ...
-    // currently the mapping axis will always be one of x,y,z, except if the
-    // PretransformVertices step is used (it transforms the meshes into worldspace,
-    // thus changing the mapping axis)
-    if (axis * base_axis_x >= angle_epsilon)    {
-        FindMeshCenter(mesh, center, min, max);
-        diffu = max.z - min.z;
-        diffv = max.y - min.y;
-
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D& pos = mesh->mVertices[pnt];
-            out[pnt].Set((pos.z - min.z) / diffu,(pos.y - min.y) / diffv,0.0);
-        }
-    }
-    else if (axis * base_axis_y >= angle_epsilon)   {
-        FindMeshCenter(mesh, center, min, max);
-        diffu = max.x - min.x;
-        diffv = max.z - min.z;
-
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D& pos = mesh->mVertices[pnt];
-            out[pnt].Set((pos.x - min.x) / diffu,(pos.z - min.z) / diffv,0.0);
-        }
-    }
-    else if (axis * base_axis_z >= angle_epsilon)   {
-        FindMeshCenter(mesh, center, min, max);
-        diffu = max.x - min.x;
-        diffv = max.y - min.y;
-
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D& pos = mesh->mVertices[pnt];
-            out[pnt].Set((pos.x - min.x) / diffu,(pos.y - min.y) / diffv,0.0);
-        }
-    }
-    // slower code path in case the mapping axis is not one of the coordinate system axes
-    else
-    {
-        aiMatrix4x4 mTrafo;
-        aiMatrix4x4::FromToMatrix(axis,base_axis_y,mTrafo);
-        FindMeshCenterTransformed(mesh, center, min, max,mTrafo);
-        diffu = max.x - min.x;
-        diffv = max.z - min.z;
-
-        // again the same, except we're applying a transformation now
-        for (unsigned int pnt = 0; pnt < mesh->mNumVertices;++pnt)  {
-            const aiVector3D pos = mTrafo * mesh->mVertices[pnt];
-            out[pnt].Set((pos.x - min.x) / diffu,(pos.z - min.z) / diffv,0.0);
-        }
-    }
-
-    // shouldn't be necessary to remove UV seams ...
-}
-
-// ------------------------------------------------------------------------------------------------
-void ComputeUVMappingProcess::ComputeBoxMapping( aiMesh*, aiVector3D* )
-{
-    ASSIMP_LOG_ERROR("Mapping type currently not implemented");
-}
-
-// ------------------------------------------------------------------------------------------------
-void ComputeUVMappingProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("GenUVCoordsProcess begin");
-    char buffer[1024];
-
-    if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT)
-        throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
-
-    std::list<MappingInfo> mappingStack;
-
-    /*  Iterate through all materials and search for non-UV mapped textures
-     */
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
-    {
-        mappingStack.clear();
-        aiMaterial* mat = pScene->mMaterials[i];
-        for (unsigned int a = 0; a < mat->mNumProperties;++a)
-        {
-            aiMaterialProperty* prop = mat->mProperties[a];
-            if (!::strcmp( prop->mKey.data, "$tex.mapping"))
-            {
-                aiTextureMapping& mapping = *((aiTextureMapping*)prop->mData);
-                if (aiTextureMapping_UV != mapping)
-                {
-                    if (!DefaultLogger::isNullLogger())
-                    {
-                        ai_snprintf(buffer, 1024, "Found non-UV mapped texture (%s,%u). Mapping type: %s",
-                            TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex,
-                            MappingTypeToString(mapping));
-
-                        ASSIMP_LOG_INFO(buffer);
-                    }
-
-                    if (aiTextureMapping_OTHER == mapping)
-                        continue;
-
-                    MappingInfo info (mapping);
-
-                    // Get further properties - currently only the major axis
-                    for (unsigned int a2 = 0; a2 < mat->mNumProperties;++a2)
-                    {
-                        aiMaterialProperty* prop2 = mat->mProperties[a2];
-                        if (prop2->mSemantic != prop->mSemantic || prop2->mIndex != prop->mIndex)
-                            continue;
-
-                        if ( !::strcmp( prop2->mKey.data, "$tex.mapaxis"))  {
-                            info.axis = *((aiVector3D*)prop2->mData);
-                            break;
-                        }
-                    }
-
-                    unsigned int idx( 99999999 );
-
-                    // Check whether we have this mapping mode already
-                    std::list<MappingInfo>::iterator it = std::find (mappingStack.begin(),mappingStack.end(), info);
-                    if (mappingStack.end() != it)
-                    {
-                        idx = (*it).uv;
-                    }
-                    else
-                    {
-                        /*  We have found a non-UV mapped texture. Now
-                        *   we need to find all meshes using this material
-                        *   that we can compute UV channels for them.
-                        */
-                        for (unsigned int m = 0; m < pScene->mNumMeshes;++m)
-                        {
-                            aiMesh* mesh = pScene->mMeshes[m];
-                            unsigned int outIdx = 0;
-                            if ( mesh->mMaterialIndex != i || ( outIdx = FindEmptyUVChannel(mesh) ) == UINT_MAX ||
-                                !mesh->mNumVertices)
-                            {
-                                continue;
-                            }
-
-                            // Allocate output storage
-                            aiVector3D* p = mesh->mTextureCoords[outIdx] = new aiVector3D[mesh->mNumVertices];
-
-                            switch (mapping)
-                            {
-                            case aiTextureMapping_SPHERE:
-                                ComputeSphereMapping(mesh,info.axis,p);
-                                break;
-                            case aiTextureMapping_CYLINDER:
-                                ComputeCylinderMapping(mesh,info.axis,p);
-                                break;
-                            case aiTextureMapping_PLANE:
-                                ComputePlaneMapping(mesh,info.axis,p);
-                                break;
-                            case aiTextureMapping_BOX:
-                                ComputeBoxMapping(mesh,p);
-                                break;
-                            default:
-                                ai_assert(false);
-                            }
-                            if (m && idx != outIdx)
-                            {
-                                ASSIMP_LOG_WARN("UV index mismatch. Not all meshes assigned to "
-                                    "this material have equal numbers of UV channels. The UV index stored in  "
-                                    "the material structure does therefore not apply for all meshes. ");
-                            }
-                            idx = outIdx;
-                        }
-                        info.uv = idx;
-                        mappingStack.push_back(info);
-                    }
-
-                    // Update the material property list
-                    mapping = aiTextureMapping_UV;
-                    ((aiMaterial*)mat)->AddProperty(&idx,1,AI_MATKEY_UVWSRC(prop->mSemantic,prop->mIndex));
-                }
-            }
-        }
-    }
-    ASSIMP_LOG_DEBUG("GenUVCoordsProcess finished");
-}
diff --git a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h b/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h
deleted file mode 100644
index a6d36e06ea..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ComputeUVMappingProcess.h
+++ /dev/null
@@ -1,149 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to compute UV coordinates
-  from abstract mappings, such as box or spherical*/
-#ifndef AI_COMPUTEUVMAPPING_H_INC
-#define AI_COMPUTEUVMAPPING_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-#include <assimp/material.h>
-#include <assimp/types.h>
-
-class ComputeUVMappingTest;
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** ComputeUVMappingProcess - converts special mappings, such as spherical,
- *  cylindrical or boxed to proper UV coordinates for rendering.
-*/
-class ComputeUVMappingProcess : public BaseProcess
-{
-public:
-    ComputeUVMappingProcess();
-    ~ComputeUVMappingProcess();
-
-public:
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-    * @param pFlags The processing flags the importer was called with. A bitwise
-    *   combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-protected:
-
-    // -------------------------------------------------------------------
-    /** Computes spherical UV coordinates for a mesh
-     *
-     *  @param mesh Mesh to be processed
-     *  @param axis Main axis
-     *  @param out Receives output UV coordinates
-    */
-    void ComputeSphereMapping(aiMesh* mesh,const aiVector3D& axis,
-        aiVector3D* out);
-
-    // -------------------------------------------------------------------
-    /** Computes cylindrical UV coordinates for a mesh
-     *
-     *  @param mesh Mesh to be processed
-     *  @param axis Main axis
-     *  @param out Receives output UV coordinates
-    */
-    void ComputeCylinderMapping(aiMesh* mesh,const aiVector3D& axis,
-        aiVector3D* out);
-
-    // -------------------------------------------------------------------
-    /** Computes planar UV coordinates for a mesh
-     *
-     *  @param mesh Mesh to be processed
-     *  @param axis Main axis
-     *  @param out Receives output UV coordinates
-    */
-    void ComputePlaneMapping(aiMesh* mesh,const aiVector3D& axis,
-        aiVector3D* out);
-
-    // -------------------------------------------------------------------
-    /** Computes cubic UV coordinates for a mesh
-     *
-     *  @param mesh Mesh to be processed
-     *  @param out Receives output UV coordinates
-    */
-    void ComputeBoxMapping(aiMesh* mesh, aiVector3D* out);
-
-private:
-
-    // temporary structure to describe a mapping
-    struct MappingInfo
-    {
-        explicit MappingInfo(aiTextureMapping _type)
-            : type  (_type)
-            , axis  (0.f,1.f,0.f)
-            , uv    (0u)
-        {}
-
-        aiTextureMapping type;
-        aiVector3D axis;
-        unsigned int uv;
-
-        bool operator== (const MappingInfo& other)
-        {
-            return type == other.type && axis == other.axis;
-        }
-    };
-};
-
-} // end of namespace Assimp
-
-#endif // AI_COMPUTEUVMAPPING_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp b/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp
deleted file mode 100644
index b7cd4f0bc6..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.cpp
+++ /dev/null
@@ -1,414 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  MakeLeftHandedProcess.cpp
- *  @brief Implementation of the post processing step to convert all
- *  imported data to a left-handed coordinate system.
- *
- *  Face order & UV flip are also implemented here, for the sake of a
- *  better location.
- */
-
-
-#include "ConvertToLHProcess.h"
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-#include <assimp/DefaultLogger.hpp>
-
-using namespace Assimp;
-
-#ifndef ASSIMP_BUILD_NO_MAKELEFTHANDED_PROCESS
-
-namespace {
-
-template <typename aiMeshType>
-void flipUVs(aiMeshType* pMesh) {
-    if (pMesh == nullptr) { return; }
-    // mirror texture y coordinate
-    for (unsigned int tcIdx = 0; tcIdx < AI_MAX_NUMBER_OF_TEXTURECOORDS; tcIdx++) {
-        if (!pMesh->HasTextureCoords(tcIdx)) {
-            break;
-        }
-
-        for (unsigned int vIdx = 0; vIdx < pMesh->mNumVertices; vIdx++) {
-            pMesh->mTextureCoords[tcIdx][vIdx].y = 1.0f - pMesh->mTextureCoords[tcIdx][vIdx].y;
-        }
-    }
-}
-
-} // namespace
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-MakeLeftHandedProcess::MakeLeftHandedProcess()
-: BaseProcess() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-MakeLeftHandedProcess::~MakeLeftHandedProcess() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool MakeLeftHandedProcess::IsActive( unsigned int pFlags) const
-{
-    return 0 != (pFlags & aiProcess_MakeLeftHanded);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void MakeLeftHandedProcess::Execute( aiScene* pScene)
-{
-    // Check for an existent root node to proceed
-    ai_assert(pScene->mRootNode != NULL);
-    ASSIMP_LOG_DEBUG("MakeLeftHandedProcess begin");
-
-    // recursively convert all the nodes
-    ProcessNode( pScene->mRootNode, aiMatrix4x4());
-
-    // process the meshes accordingly
-    for ( unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
-        ProcessMesh( pScene->mMeshes[ a ] );
-    }
-
-    // process the materials accordingly
-    for ( unsigned int a = 0; a < pScene->mNumMaterials; ++a ) {
-        ProcessMaterial( pScene->mMaterials[ a ] );
-    }
-
-    // transform all animation channels as well
-    for( unsigned int a = 0; a < pScene->mNumAnimations; a++)
-    {
-        aiAnimation* anim = pScene->mAnimations[a];
-        for( unsigned int b = 0; b < anim->mNumChannels; b++)
-        {
-            aiNodeAnim* nodeAnim = anim->mChannels[b];
-            ProcessAnimation( nodeAnim);
-        }
-    }
-    ASSIMP_LOG_DEBUG("MakeLeftHandedProcess finished");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Recursively converts a node, all of its children and all of its meshes
-void MakeLeftHandedProcess::ProcessNode( aiNode* pNode, const aiMatrix4x4& pParentGlobalRotation)
-{
-    // mirror all base vectors at the local Z axis
-    pNode->mTransformation.c1 = -pNode->mTransformation.c1;
-    pNode->mTransformation.c2 = -pNode->mTransformation.c2;
-    pNode->mTransformation.c3 = -pNode->mTransformation.c3;
-    pNode->mTransformation.c4 = -pNode->mTransformation.c4;
-
-    // now invert the Z axis again to keep the matrix determinant positive.
-    // The local meshes will be inverted accordingly so that the result should look just fine again.
-    pNode->mTransformation.a3 = -pNode->mTransformation.a3;
-    pNode->mTransformation.b3 = -pNode->mTransformation.b3;
-    pNode->mTransformation.c3 = -pNode->mTransformation.c3;
-    pNode->mTransformation.d3 = -pNode->mTransformation.d3; // useless, but anyways...
-
-    // continue for all children
-    for( size_t a = 0; a < pNode->mNumChildren; ++a ) {
-        ProcessNode( pNode->mChildren[ a ], pParentGlobalRotation * pNode->mTransformation );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Converts a single mesh to left handed coordinates.
-void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) {
-    if ( nullptr == pMesh ) {
-        ASSIMP_LOG_ERROR( "Nullptr to mesh found." );
-        return;
-    }
-    // mirror positions, normals and stuff along the Z axis
-    for( size_t a = 0; a < pMesh->mNumVertices; ++a)
-    {
-        pMesh->mVertices[a].z *= -1.0f;
-        if (pMesh->HasNormals()) {
-            pMesh->mNormals[a].z *= -1.0f;
-        }
-        if( pMesh->HasTangentsAndBitangents())
-        {
-            pMesh->mTangents[a].z *= -1.0f;
-            pMesh->mBitangents[a].z *= -1.0f;
-        }
-    }
-
-    // mirror anim meshes positions, normals and stuff along the Z axis
-    for (size_t m = 0; m < pMesh->mNumAnimMeshes; ++m)
-    {
-        for (size_t a = 0; a < pMesh->mAnimMeshes[m]->mNumVertices; ++a)
-        {
-            pMesh->mAnimMeshes[m]->mVertices[a].z *= -1.0f;
-            if (pMesh->mAnimMeshes[m]->HasNormals()) {
-                pMesh->mAnimMeshes[m]->mNormals[a].z *= -1.0f;
-            }
-            if (pMesh->mAnimMeshes[m]->HasTangentsAndBitangents())
-            {
-                pMesh->mAnimMeshes[m]->mTangents[a].z *= -1.0f;
-                pMesh->mAnimMeshes[m]->mBitangents[a].z *= -1.0f;
-            }
-        }
-    }
-
-    // mirror offset matrices of all bones
-    for( size_t a = 0; a < pMesh->mNumBones; ++a)
-    {
-        aiBone* bone = pMesh->mBones[a];
-        bone->mOffsetMatrix.a3 = -bone->mOffsetMatrix.a3;
-        bone->mOffsetMatrix.b3 = -bone->mOffsetMatrix.b3;
-        bone->mOffsetMatrix.d3 = -bone->mOffsetMatrix.d3;
-        bone->mOffsetMatrix.c1 = -bone->mOffsetMatrix.c1;
-        bone->mOffsetMatrix.c2 = -bone->mOffsetMatrix.c2;
-        bone->mOffsetMatrix.c4 = -bone->mOffsetMatrix.c4;
-    }
-
-    // mirror bitangents as well as they're derived from the texture coords
-    if( pMesh->HasTangentsAndBitangents())
-    {
-        for( unsigned int a = 0; a < pMesh->mNumVertices; a++)
-            pMesh->mBitangents[a] *= -1.0f;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Converts a single material to left handed coordinates.
-void MakeLeftHandedProcess::ProcessMaterial( aiMaterial* _mat) {
-    if ( nullptr == _mat ) {
-        ASSIMP_LOG_ERROR( "Nullptr to aiMaterial found." );
-        return;
-    }
-
-    aiMaterial* mat = (aiMaterial*)_mat;
-    for (unsigned int a = 0; a < mat->mNumProperties;++a)   {
-        aiMaterialProperty* prop = mat->mProperties[a];
-
-        // Mapping axis for UV mappings?
-        if (!::strcmp( prop->mKey.data, "$tex.mapaxis"))    {
-            ai_assert( prop->mDataLength >= sizeof(aiVector3D)); /* something is wrong with the validation if we end up here */
-            aiVector3D* pff = (aiVector3D*)prop->mData;
-            pff->z *= -1.f;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Converts the given animation to LH coordinates.
-void MakeLeftHandedProcess::ProcessAnimation( aiNodeAnim* pAnim)
-{
-    // position keys
-    for( unsigned int a = 0; a < pAnim->mNumPositionKeys; a++)
-        pAnim->mPositionKeys[a].mValue.z *= -1.0f;
-
-    // rotation keys
-    for( unsigned int a = 0; a < pAnim->mNumRotationKeys; a++)
-    {
-        /* That's the safe version, but the float errors add up. So we try the short version instead
-        aiMatrix3x3 rotmat = pAnim->mRotationKeys[a].mValue.GetMatrix();
-        rotmat.a3 = -rotmat.a3; rotmat.b3 = -rotmat.b3;
-        rotmat.c1 = -rotmat.c1; rotmat.c2 = -rotmat.c2;
-        aiQuaternion rotquat( rotmat);
-        pAnim->mRotationKeys[a].mValue = rotquat;
-        */
-        pAnim->mRotationKeys[a].mValue.x *= -1.0f;
-        pAnim->mRotationKeys[a].mValue.y *= -1.0f;
-    }
-}
-
-#endif // !!  ASSIMP_BUILD_NO_MAKELEFTHANDED_PROCESS
-#ifndef  ASSIMP_BUILD_NO_FLIPUVS_PROCESS
-// # FlipUVsProcess
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-FlipUVsProcess::FlipUVsProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FlipUVsProcess::~FlipUVsProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool FlipUVsProcess::IsActive( unsigned int pFlags) const
-{
-    return 0 != (pFlags & aiProcess_FlipUVs);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void FlipUVsProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("FlipUVsProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-        ProcessMesh(pScene->mMeshes[i]);
-
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
-        ProcessMaterial(pScene->mMaterials[i]);
-    ASSIMP_LOG_DEBUG("FlipUVsProcess finished");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Converts a single material
-void FlipUVsProcess::ProcessMaterial (aiMaterial* _mat)
-{
-    aiMaterial* mat = (aiMaterial*)_mat;
-    for (unsigned int a = 0; a < mat->mNumProperties;++a)   {
-        aiMaterialProperty* prop = mat->mProperties[a];
-        if( !prop ) {
-            ASSIMP_LOG_DEBUG( "Property is null" );
-            continue;
-        }
-
-        // UV transformation key?
-        if (!::strcmp( prop->mKey.data, "$tex.uvtrafo"))    {
-            ai_assert( prop->mDataLength >= sizeof(aiUVTransform));  /* something is wrong with the validation if we end up here */
-            aiUVTransform* uv = (aiUVTransform*)prop->mData;
-
-            // just flip it, that's everything
-            uv->mTranslation.y *= -1.f;
-            uv->mRotation *= -1.f;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Converts a single mesh
-void FlipUVsProcess::ProcessMesh( aiMesh* pMesh)
-{
-    flipUVs(pMesh);
-    for (unsigned int idx = 0; idx < pMesh->mNumAnimMeshes; idx++) {
-        flipUVs(pMesh->mAnimMeshes[idx]);
-    }
-}
-
-#endif // !ASSIMP_BUILD_NO_FLIPUVS_PROCESS
-#ifndef  ASSIMP_BUILD_NO_FLIPWINDING_PROCESS
-// # FlipWindingOrderProcess
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-FlipWindingOrderProcess::FlipWindingOrderProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FlipWindingOrderProcess::~FlipWindingOrderProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool FlipWindingOrderProcess::IsActive( unsigned int pFlags) const
-{
-    return 0 != (pFlags & aiProcess_FlipWindingOrder);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void FlipWindingOrderProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("FlipWindingOrderProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-        ProcessMesh(pScene->mMeshes[i]);
-    ASSIMP_LOG_DEBUG("FlipWindingOrderProcess finished");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Converts a single mesh
-void FlipWindingOrderProcess::ProcessMesh( aiMesh* pMesh)
-{
-    // invert the order of all faces in this mesh
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        aiFace& face = pMesh->mFaces[a];
-        for (unsigned int b = 0; b < face.mNumIndices / 2; b++) {
-            std::swap(face.mIndices[b], face.mIndices[face.mNumIndices - 1 - b]);
-        }
-    }
-
-    // invert the order of all components in this mesh anim meshes
-    for (unsigned int m = 0; m < pMesh->mNumAnimMeshes; m++) {
-        aiAnimMesh* animMesh = pMesh->mAnimMeshes[m];
-        unsigned int numVertices = animMesh->mNumVertices;
-        if (animMesh->HasPositions()) {
-            for (unsigned int a = 0; a < numVertices; a++)
-            {
-                std::swap(animMesh->mVertices[a], animMesh->mVertices[numVertices - 1 - a]);
-            }
-        }
-        if (animMesh->HasNormals()) {
-            for (unsigned int a = 0; a < numVertices; a++)
-            {
-                std::swap(animMesh->mNormals[a], animMesh->mNormals[numVertices - 1 - a]);
-            }
-        }
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; i++) {
-            if (animMesh->HasTextureCoords(i)) {
-                for (unsigned int a = 0; a < numVertices; a++)
-                {
-                    std::swap(animMesh->mTextureCoords[i][a], animMesh->mTextureCoords[i][numVertices - 1 - a]);
-                }
-            }
-        }
-        if (animMesh->HasTangentsAndBitangents()) {
-            for (unsigned int a = 0; a < numVertices; a++)
-            {
-                std::swap(animMesh->mTangents[a], animMesh->mTangents[numVertices - 1 - a]);
-                std::swap(animMesh->mBitangents[a], animMesh->mBitangents[numVertices - 1 - a]);
-            }
-        }
-        for (unsigned int v = 0; v < AI_MAX_NUMBER_OF_COLOR_SETS; v++) {
-            if (animMesh->HasVertexColors(v)) {
-                for (unsigned int a = 0; a < numVertices; a++)
-                {
-                    std::swap(animMesh->mColors[v][a], animMesh->mColors[v][numVertices - 1 - a]);
-                }
-            }
-        }
-    }
-}
-
-#endif // !! ASSIMP_BUILD_NO_FLIPWINDING_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h b/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h
deleted file mode 100644
index f32b91fc39..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ConvertToLHProcess.h
+++ /dev/null
@@ -1,171 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  MakeLeftHandedProcess.h
- *  @brief Defines a bunch of post-processing steps to handle
- *    coordinate system conversions.
- *
- *  - LH to RH
- *  - UV origin upper-left to lower-left
- *  - face order cw to ccw
- */
-#ifndef AI_CONVERTTOLHPROCESS_H_INC
-#define AI_CONVERTTOLHPROCESS_H_INC
-
-#include <assimp/types.h>
-
-#include "Common/BaseProcess.h"
-
-struct aiMesh;
-struct aiNodeAnim;
-struct aiNode;
-struct aiMaterial;
-
-namespace Assimp    {
-
-// -----------------------------------------------------------------------------------
-/** @brief The MakeLeftHandedProcess converts all imported data to a left-handed
- *   coordinate system.
- *
- * This implies a mirroring of the Z axis of the coordinate system. But to keep
- * transformation matrices free from reflections we shift the reflection to other
- * places. We mirror the meshes and adapt the rotations.
- *
- * @note RH-LH and LH-RH is the same, so this class can be used for both
- */
-class MakeLeftHandedProcess : public BaseProcess
-{
-
-
-public:
-    MakeLeftHandedProcess();
-    ~MakeLeftHandedProcess();
-
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-protected:
-
-    // -------------------------------------------------------------------
-    /** Recursively converts a node and all of its children
-     */
-    void ProcessNode( aiNode* pNode, const aiMatrix4x4& pParentGlobalRotation);
-
-    // -------------------------------------------------------------------
-    /** Converts a single mesh to left handed coordinates.
-     * This means that positions, normals and tangents are mirrored at
-     * the local Z axis and the order of all faces are inverted.
-     * @param pMesh The mesh to convert.
-     */
-    void ProcessMesh( aiMesh* pMesh);
-
-    // -------------------------------------------------------------------
-    /** Converts a single material to left-handed coordinates
-     * @param pMat Material to convert
-     */
-    void ProcessMaterial( aiMaterial* pMat);
-
-    // -------------------------------------------------------------------
-    /** Converts the given animation to LH coordinates.
-     * The rotation and translation keys are transformed, the scale keys
-     * work in local space and can therefore be left untouched.
-     * @param pAnim The bone animation to transform
-     */
-    void ProcessAnimation( aiNodeAnim* pAnim);
-};
-
-
-// ---------------------------------------------------------------------------
-/** Postprocessing step to flip the face order of the imported data
- */
-class FlipWindingOrderProcess : public BaseProcess
-{
-    friend class Importer;
-
-public:
-    /** Constructor to be privately used by Importer */
-    FlipWindingOrderProcess();
-
-    /** Destructor, private as well */
-    ~FlipWindingOrderProcess();
-
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-protected:
-    void ProcessMesh( aiMesh* pMesh);
-};
-
-// ---------------------------------------------------------------------------
-/** Postprocessing step to flip the UV coordinate system of the import data
- */
-class FlipUVsProcess : public BaseProcess
-{
-    friend class Importer;
-
-public:
-    /** Constructor to be privately used by Importer */
-    FlipUVsProcess();
-
-    /** Destructor, private as well */
-    ~FlipUVsProcess();
-
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-protected:
-    void ProcessMesh( aiMesh* pMesh);
-    void ProcessMaterial( aiMaterial* mat);
-};
-
-} // end of namespace Assimp
-
-#endif // AI_CONVERTTOLHPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp b/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp
deleted file mode 100644
index 83b8336bc9..0000000000
--- a/thirdparty/assimp/code/PostProcessing/DeboneProcess.cpp
+++ /dev/null
@@ -1,465 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/// @file DeboneProcess.cpp
-/** Implementation of the DeboneProcess post processing step */
-
-
-
-// internal headers of the post-processing framework
-#include "ProcessHelper.h"
-#include "DeboneProcess.h"
-#include <stdio.h>
-
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-DeboneProcess::DeboneProcess()
-{
-    mNumBones = 0;
-    mNumBonesCanDoWithout = 0;
-
-    mThreshold = AI_DEBONE_THRESHOLD;
-    mAllOrNone = false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-DeboneProcess::~DeboneProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool DeboneProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_Debone) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void DeboneProcess::SetupProperties(const Importer* pImp)
-{
-    // get the current value of the property
-    mAllOrNone = pImp->GetPropertyInteger(AI_CONFIG_PP_DB_ALL_OR_NONE,0)?true:false;
-    mThreshold = pImp->GetPropertyFloat(AI_CONFIG_PP_DB_THRESHOLD,AI_DEBONE_THRESHOLD);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void DeboneProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("DeboneProcess begin");
-
-    if(!pScene->mNumMeshes) {
-        return;
-    }
-
-    std::vector<bool> splitList(pScene->mNumMeshes);
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++) {
-        splitList[a] = ConsiderMesh( pScene->mMeshes[a] );
-    }
-
-    int numSplits = 0;
-
-    if(!!mNumBonesCanDoWithout && (!mAllOrNone||mNumBonesCanDoWithout==mNumBones))  {
-        for(unsigned int a = 0; a < pScene->mNumMeshes; a++)    {
-            if(splitList[a]) {
-                numSplits++;
-            }
-        }
-    }
-
-    if(numSplits)   {
-        // we need to do something. Let's go.
-        //mSubMeshIndices.clear();                  // really needed?
-        mSubMeshIndices.resize(pScene->mNumMeshes); // because we're doing it here anyway
-
-        // build a new array of meshes for the scene
-        std::vector<aiMesh*> meshes;
-
-        for(unsigned int a=0;a<pScene->mNumMeshes;a++)
-        {
-            aiMesh* srcMesh = pScene->mMeshes[a];
-
-            std::vector<std::pair<aiMesh*,const aiBone*> > newMeshes;
-
-            if(splitList[a]) {
-                SplitMesh(srcMesh,newMeshes);
-            }
-
-            // mesh was split
-            if(!newMeshes.empty())  {
-                unsigned int out = 0, in = srcMesh->mNumBones;
-
-                // store new meshes and indices of the new meshes
-                for(unsigned int b=0;b<newMeshes.size();b++)    {
-                    const aiString *find = newMeshes[b].second?&newMeshes[b].second->mName:0;
-
-                    aiNode *theNode = find?pScene->mRootNode->FindNode(*find):0;
-                    std::pair<unsigned int,aiNode*> push_pair(static_cast<unsigned int>(meshes.size()),theNode);
-
-                    mSubMeshIndices[a].push_back(push_pair);
-                    meshes.push_back(newMeshes[b].first);
-
-                    out+=newMeshes[b].first->mNumBones;
-                }
-
-                if(!DefaultLogger::isNullLogger()) {
-                    ASSIMP_LOG_INFO_F("Removed %u bones. Input bones:", in - out, ". Output bones: ", out);
-                }
-
-                // and destroy the source mesh. It should be completely contained inside the new submeshes
-                delete srcMesh;
-            }
-            else    {
-                // Mesh is kept unchanged - store it's new place in the mesh array
-                mSubMeshIndices[a].push_back(std::pair<unsigned int,aiNode*>(static_cast<unsigned int>(meshes.size()),(aiNode*)0));
-                meshes.push_back(srcMesh);
-            }
-        }
-
-        // rebuild the scene's mesh array
-        pScene->mNumMeshes = static_cast<unsigned int>(meshes.size());
-        delete [] pScene->mMeshes;
-        pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-        std::copy( meshes.begin(), meshes.end(), pScene->mMeshes);
-
-        // recurse through all nodes and translate the node's mesh indices to fit the new mesh array
-        UpdateNode( pScene->mRootNode);
-    }
-
-    ASSIMP_LOG_DEBUG("DeboneProcess end");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Counts bones total/removable in a given mesh.
-bool DeboneProcess::ConsiderMesh(const aiMesh* pMesh)
-{
-    if(!pMesh->HasBones()) {
-        return false;
-    }
-
-    bool split = false;
-
-    //interstitial faces not permitted
-    bool isInterstitialRequired = false;
-
-    std::vector<bool> isBoneNecessary(pMesh->mNumBones,false);
-    std::vector<unsigned int> vertexBones(pMesh->mNumVertices,UINT_MAX);
-
-    const unsigned int cUnowned = UINT_MAX;
-    const unsigned int cCoowned = UINT_MAX-1;
-
-    for(unsigned int i=0;i<pMesh->mNumBones;i++)    {
-        for(unsigned int j=0;j<pMesh->mBones[i]->mNumWeights;j++)   {
-            float w = pMesh->mBones[i]->mWeights[j].mWeight;
-
-            if(w==0.0f) {
-                continue;
-            }
-
-            unsigned int vid = pMesh->mBones[i]->mWeights[j].mVertexId;
-            if(w>=mThreshold)   {
-
-                if(vertexBones[vid]!=cUnowned)  {
-                    if(vertexBones[vid]==i) //double entry
-                    {
-                        ASSIMP_LOG_WARN("Encountered double entry in bone weights");
-                    }
-                    else //TODO: track attraction in order to break tie
-                    {
-                        vertexBones[vid] = cCoowned;
-                    }
-                }
-                else vertexBones[vid] = i;
-            }
-
-            if(!isBoneNecessary[i]) {
-                isBoneNecessary[i] = w<mThreshold;
-            }
-        }
-
-        if(!isBoneNecessary[i])  {
-            isInterstitialRequired = true;
-        }
-    }
-
-    if(isInterstitialRequired) {
-        for(unsigned int i=0;i<pMesh->mNumFaces;i++) {
-            unsigned int v = vertexBones[pMesh->mFaces[i].mIndices[0]];
-
-            for(unsigned int j=1;j<pMesh->mFaces[i].mNumIndices;j++) {
-                unsigned int w = vertexBones[pMesh->mFaces[i].mIndices[j]];
-
-                if(v!=w)    {
-                    if(v<pMesh->mNumBones) isBoneNecessary[v] = true;
-                    if(w<pMesh->mNumBones) isBoneNecessary[w] = true;
-                }
-            }
-        }
-    }
-
-    for(unsigned int i=0;i<pMesh->mNumBones;i++)    {
-        if(!isBoneNecessary[i]) {
-            mNumBonesCanDoWithout++;
-            split = true;
-        }
-
-        mNumBones++;
-    }
-    return split;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Splits the given mesh by bone count.
-void DeboneProcess::SplitMesh( const aiMesh* pMesh, std::vector< std::pair< aiMesh*,const aiBone* > >& poNewMeshes) const
-{
-    // same deal here as ConsiderMesh basically
-
-    std::vector<bool> isBoneNecessary(pMesh->mNumBones,false);
-    std::vector<unsigned int> vertexBones(pMesh->mNumVertices,UINT_MAX);
-
-    const unsigned int cUnowned = UINT_MAX;
-    const unsigned int cCoowned = UINT_MAX-1;
-
-    for(unsigned int i=0;i<pMesh->mNumBones;i++)    {
-        for(unsigned int j=0;j<pMesh->mBones[i]->mNumWeights;j++)   {
-            float w = pMesh->mBones[i]->mWeights[j].mWeight;
-
-            if(w==0.0f) {
-                continue;
-            }
-
-            unsigned int vid = pMesh->mBones[i]->mWeights[j].mVertexId;
-
-            if(w>=mThreshold) {
-                if(vertexBones[vid]!=cUnowned)  {
-                    if(vertexBones[vid]==i) //double entry
-                    {
-                        ASSIMP_LOG_WARN("Encountered double entry in bone weights");
-                    }
-                    else //TODO: track attraction in order to break tie
-                    {
-                        vertexBones[vid] = cCoowned;
-                    }
-                }
-                else vertexBones[vid] = i;
-            }
-
-            if(!isBoneNecessary[i]) {
-                isBoneNecessary[i] = w<mThreshold;
-            }
-        }
-    }
-
-    unsigned int nFacesUnowned = 0;
-
-    std::vector<unsigned int> faceBones(pMesh->mNumFaces,UINT_MAX);
-    std::vector<unsigned int> facesPerBone(pMesh->mNumBones,0);
-
-    for(unsigned int i=0;i<pMesh->mNumFaces;i++) {
-        unsigned int nInterstitial = 1;
-
-        unsigned int v = vertexBones[pMesh->mFaces[i].mIndices[0]];
-
-        for(unsigned int j=1;j<pMesh->mFaces[i].mNumIndices;j++) {
-            unsigned int w = vertexBones[pMesh->mFaces[i].mIndices[j]];
-
-            if(v!=w)    {
-                if(v<pMesh->mNumBones) isBoneNecessary[v] = true;
-                if(w<pMesh->mNumBones) isBoneNecessary[w] = true;
-            }
-            else nInterstitial++;
-        }
-
-        if(v<pMesh->mNumBones &&nInterstitial==pMesh->mFaces[i].mNumIndices)    {
-            faceBones[i] = v; //primitive belongs to bone #v
-            facesPerBone[v]++;
-        }
-        else nFacesUnowned++;
-    }
-
-    // invalidate any "cojoined" faces
-    for(unsigned int i=0;i<pMesh->mNumFaces;i++) {
-        if(faceBones[i]<pMesh->mNumBones&&isBoneNecessary[faceBones[i]])
-        {
-            ai_assert(facesPerBone[faceBones[i]]>0);
-            facesPerBone[faceBones[i]]--;
-
-            nFacesUnowned++;
-            faceBones[i] = cUnowned;
-        }
-    }
-
-    if(nFacesUnowned) {
-        std::vector<unsigned int> subFaces;
-
-        for(unsigned int i=0;i<pMesh->mNumFaces;i++)    {
-            if(faceBones[i]==cUnowned) {
-                subFaces.push_back(i);
-            }
-        }
-
-        aiMesh *baseMesh = MakeSubmesh(pMesh,subFaces,0);
-        std::pair<aiMesh*,const aiBone*> push_pair(baseMesh,(const aiBone*)0);
-
-        poNewMeshes.push_back(push_pair);
-    }
-
-    for(unsigned int i=0;i<pMesh->mNumBones;i++) {
-
-        if(!isBoneNecessary[i]&&facesPerBone[i]>0)  {
-            std::vector<unsigned int> subFaces;
-
-            for(unsigned int j=0;j<pMesh->mNumFaces;j++)    {
-                if(faceBones[j]==i) {
-                    subFaces.push_back(j);
-                }
-            }
-
-            unsigned int f = AI_SUBMESH_FLAGS_SANS_BONES;
-            aiMesh *subMesh =MakeSubmesh(pMesh,subFaces,f);
-
-            //Lifted from PretransformVertices.cpp
-            ApplyTransform(subMesh,pMesh->mBones[i]->mOffsetMatrix);
-            std::pair<aiMesh*,const aiBone*> push_pair(subMesh,pMesh->mBones[i]);
-
-            poNewMeshes.push_back(push_pair);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Recursively updates the node's mesh list to account for the changed mesh list
-void DeboneProcess::UpdateNode(aiNode* pNode) const
-{
-    // rebuild the node's mesh index list
-
-    std::vector<unsigned int> newMeshList;
-
-    // this will require two passes
-
-    unsigned int m = static_cast<unsigned int>(pNode->mNumMeshes), n = static_cast<unsigned int>(mSubMeshIndices.size());
-
-    // first pass, look for meshes which have not moved
-
-    for(unsigned int a=0;a<m;a++)   {
-
-        unsigned int srcIndex = pNode->mMeshes[a];
-        const std::vector< std::pair< unsigned int,aiNode* > > &subMeshes = mSubMeshIndices[srcIndex];
-        unsigned int nSubmeshes = static_cast<unsigned int>(subMeshes.size());
-
-        for(unsigned int b=0;b<nSubmeshes;b++) {
-            if(!subMeshes[b].second) {
-                newMeshList.push_back(subMeshes[b].first);
-            }
-        }
-    }
-
-    // second pass, collect deboned meshes
-
-    for(unsigned int a=0;a<n;a++)
-    {
-        const std::vector< std::pair< unsigned int,aiNode* > > &subMeshes = mSubMeshIndices[a];
-        unsigned int nSubmeshes = static_cast<unsigned int>(subMeshes.size());
-
-        for(unsigned int b=0;b<nSubmeshes;b++) {
-            if(subMeshes[b].second == pNode)    {
-                newMeshList.push_back(subMeshes[b].first);
-            }
-        }
-    }
-
-    if( pNode->mNumMeshes > 0 ) {
-        delete [] pNode->mMeshes; pNode->mMeshes = NULL;
-    }
-
-    pNode->mNumMeshes = static_cast<unsigned int>(newMeshList.size());
-
-    if(pNode->mNumMeshes)   {
-        pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
-        std::copy( newMeshList.begin(), newMeshList.end(), pNode->mMeshes);
-    }
-
-    // do that also recursively for all children
-    for( unsigned int a = 0; a < pNode->mNumChildren; ++a ) {
-        UpdateNode( pNode->mChildren[a]);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Apply the node transformation to a mesh
-void DeboneProcess::ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat)const
-{
-    // 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();
-                }
-            }
-        }
-    }
-}
diff --git a/thirdparty/assimp/code/PostProcessing/DeboneProcess.h b/thirdparty/assimp/code/PostProcessing/DeboneProcess.h
deleted file mode 100644
index 8b64c2acc6..0000000000
--- a/thirdparty/assimp/code/PostProcessing/DeboneProcess.h
+++ /dev/null
@@ -1,131 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** Defines a post processing step to limit the number of bones affecting a single vertex. */
-#ifndef AI_DEBONEPROCESS_H_INC
-#define AI_DEBONEPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-#include <assimp/scene.h>
-
-#include <vector>
-#include <utility>
-
-#// Forward declarations
-class DeboneTest;
-
-namespace Assimp {
-
-#if (!defined AI_DEBONE_THRESHOLD)
-#   define AI_DEBONE_THRESHOLD  1.0f
-#endif // !! AI_DEBONE_THRESHOLD
-
-// ---------------------------------------------------------------------------
-/** This post processing step removes bones nearly losslessly or according to
-* a configured threshold. In order to remove the bone, the primitives affected by
-* the bone are split from the mesh. The split off (new) mesh is boneless. At any
-* point in time, bones without affect upon a given mesh are to be removed.
-*/
-class DeboneProcess : public BaseProcess {
-public:
-    DeboneProcess();
-    ~DeboneProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag.
-    * @param pFlags The processing flags the importer was called with.
-    *   A bitwise combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields,
-    *   false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    void SetupProperties(const Importer* pImp);
-
-protected:
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    /** Counts bones total/removable in a given mesh.
-    * @param pMesh The mesh to process.
-    */
-    bool ConsiderMesh( const aiMesh* pMesh);
-
-    /// Splits the given mesh by bone count.
-    /// @param pMesh the Mesh to split. Is not changed at all, but might be superfluous in case it was split.
-    /// @param poNewMeshes Array of submeshes created in the process. Empty if splitting was not necessary.
-    void SplitMesh(const aiMesh* pMesh, std::vector< std::pair< aiMesh*,const aiBone* > >& poNewMeshes) const;
-
-    /// Recursively updates the node's mesh list to account for the changed mesh list
-    void UpdateNode(aiNode* pNode) const;
-
-    // -------------------------------------------------------------------
-    // Apply transformation to a mesh
-    void ApplyTransform(aiMesh* mesh, const aiMatrix4x4& mat)const;
-
-public:
-    /** Number of bones present in the scene. */
-    unsigned int mNumBones;
-    unsigned int mNumBonesCanDoWithout;
-
-    float mThreshold;
-    bool mAllOrNone;
-
-    /// Per mesh index: Array of indices of the new submeshes.
-    std::vector< std::vector< std::pair< unsigned int,aiNode* > > > mSubMeshIndices;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_DEBONEPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp b/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
deleted file mode 100644
index b11615bb82..0000000000
--- a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.cpp
+++ /dev/null
@@ -1,109 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to drop face
-* normals for all imported faces.
-*/
-
-
-#include "DropFaceNormalsProcess.h"
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-DropFaceNormalsProcess::DropFaceNormalsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-DropFaceNormalsProcess::~DropFaceNormalsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool DropFaceNormalsProcess::IsActive( unsigned int pFlags) const {
-    return  (pFlags & aiProcess_DropNormals) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void DropFaceNormalsProcess::Execute( aiScene* pScene) {
-    ASSIMP_LOG_DEBUG("DropFaceNormalsProcess begin");
-
-    if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
-        throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
-    }
-
-    bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++) {
-        bHas |= this->DropMeshFaceNormals( pScene->mMeshes[a]);
-    }
-    if (bHas)   {
-        ASSIMP_LOG_INFO("DropFaceNormalsProcess finished. "
-            "Face normals have been removed");
-    } else {
-        ASSIMP_LOG_DEBUG("DropFaceNormalsProcess finished. "
-            "No normals were present");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-bool DropFaceNormalsProcess::DropMeshFaceNormals (aiMesh* pMesh) {
-    if (NULL == pMesh->mNormals) {
-        return false;
-    }
-    
-    delete[] pMesh->mNormals;
-    pMesh->mNormals = nullptr;
-    return true;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h b/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h
deleted file mode 100644
index c710c5a5ee..0000000000
--- a/thirdparty/assimp/code/PostProcessing/DropFaceNormalsProcess.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to compute face normals for all loaded faces*/
-#ifndef AI_DROPFACENORMALPROCESS_H_INC
-#define AI_DROPFACENORMALPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** The DropFaceNormalsProcess computes face normals for all faces of all meshes
-*/
-class ASSIMP_API_WINONLY DropFaceNormalsProcess : public BaseProcess {
-public:
-    DropFaceNormalsProcess();
-    ~DropFaceNormalsProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-    * @param pFlags The processing flags the importer was called with. A bitwise
-    *   combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-
-private:
-    bool DropMeshFaceNormals(aiMesh* pcMesh);
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_DROPFACENORMALPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp b/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
deleted file mode 100644
index 739382a057..0000000000
--- a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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 "EmbedTexturesProcess.h"
-#include <assimp/ParsingUtils.h>
-#include "ProcessHelper.h"
-
-#include <fstream>
-
-using namespace Assimp;
-
-EmbedTexturesProcess::EmbedTexturesProcess()
-: BaseProcess() {
-}
-
-EmbedTexturesProcess::~EmbedTexturesProcess() {
-}
-
-bool EmbedTexturesProcess::IsActive(unsigned int pFlags) const {
-    return (pFlags & aiProcess_EmbedTextures) != 0;
-}
-
-void EmbedTexturesProcess::SetupProperties(const Importer* pImp) {
-    mRootPath = pImp->GetPropertyString("sourceFilePath");
-    mRootPath = mRootPath.substr(0, mRootPath.find_last_of("\\/") + 1u);
-}
-
-void EmbedTexturesProcess::Execute(aiScene* pScene) {
-    if (pScene == nullptr || pScene->mRootNode == nullptr) return;
-
-    aiString path;
-
-    uint32_t embeddedTexturesCount = 0u;
-
-    for (auto matId = 0u; matId < pScene->mNumMaterials; ++matId) {
-        auto material = pScene->mMaterials[matId];
-
-        for (auto ttId = 1u; ttId < AI_TEXTURE_TYPE_MAX; ++ttId) {
-            auto tt = static_cast<aiTextureType>(ttId);
-            auto texturesCount = material->GetTextureCount(tt);
-
-            for (auto texId = 0u; texId < texturesCount; ++texId) {
-                material->GetTexture(tt, texId, &path);
-                if (path.data[0] == '*') continue; // Already embedded
-
-                // Indeed embed
-                if (addTexture(pScene, path.data)) {
-                    auto embeddedTextureId = pScene->mNumTextures - 1u;
-                    ::ai_snprintf(path.data, 1024, "*%u", embeddedTextureId);
-                    material->AddProperty(&path, AI_MATKEY_TEXTURE(tt, texId));
-                    embeddedTexturesCount++;
-                }
-            }
-        }
-    }
-
-    ASSIMP_LOG_INFO_F("EmbedTexturesProcess finished. Embedded ", embeddedTexturesCount, " textures." );
-}
-
-bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
-    std::streampos imageSize = 0;
-    std::string    imagePath = path;
-
-    // Test path directly
-    std::ifstream file(imagePath, std::ios::binary | std::ios::ate);
-    if ((imageSize = file.tellg()) == std::streampos(-1)) {
-        ASSIMP_LOG_WARN_F("EmbedTexturesProcess: Cannot find image: ", imagePath, ". Will try to find it in root folder.");
-
-        // Test path in root path
-        imagePath = mRootPath + path;
-        file.open(imagePath, std::ios::binary | std::ios::ate);
-        if ((imageSize = file.tellg()) == std::streampos(-1)) {
-            // Test path basename in root path
-            imagePath = mRootPath + path.substr(path.find_last_of("\\/") + 1u);
-            file.open(imagePath, std::ios::binary | std::ios::ate);
-            if ((imageSize = file.tellg()) == std::streampos(-1)) {
-                ASSIMP_LOG_ERROR_F("EmbedTexturesProcess: Unable to embed texture: ", path, ".");
-                return false;
-            }
-        }
-    }
-
-    aiTexel* imageContent = new aiTexel[ 1ul + static_cast<unsigned long>( imageSize ) / sizeof(aiTexel)];
-    file.seekg(0, std::ios::beg);
-    file.read(reinterpret_cast<char*>(imageContent), imageSize);
-
-    // Enlarging the textures table
-    unsigned int textureId = pScene->mNumTextures++;
-    auto oldTextures = pScene->mTextures;
-    pScene->mTextures = new aiTexture*[pScene->mNumTextures];
-    ::memmove(pScene->mTextures, oldTextures, sizeof(aiTexture*) * (pScene->mNumTextures - 1u));
-
-    // Add the new texture
-    auto pTexture = new aiTexture;
-    pTexture->mHeight = 0; // Means that this is still compressed
-    pTexture->mWidth = static_cast<uint32_t>(imageSize);
-    pTexture->pcData = imageContent;
-
-    auto extension = path.substr(path.find_last_of('.') + 1u);
-    std::transform(extension.begin(), extension.end(), extension.begin(), ::tolower);
-    if (extension == "jpeg") {
-        extension = "jpg";
-    }
-
-    size_t len = extension.size();
-    if (len > HINTMAXTEXTURELEN -1 ) {
-        len = HINTMAXTEXTURELEN - 1;
-    }
-    ::strncpy(pTexture->achFormatHint, extension.c_str(), len);
-    pScene->mTextures[textureId] = pTexture;
-
-    return true;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h b/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h
deleted file mode 100644
index 3c4b2eab4e..0000000000
--- a/thirdparty/assimp/code/PostProcessing/EmbedTexturesProcess.h
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-#pragma once
-
-#include "Common/BaseProcess.h"
-
-#include <string>
-
-struct aiNode;
-
-namespace Assimp {
-
-/**
- *  Force embedding of textures (using the path = "*1" convention).
- *  If a texture's file does not exist at the specified path
- *  (due, for instance, to an absolute path generated on another system),
- *  it will check if a file with the same name exists at the root folder
- *  of the imported model. And if so, it uses that.
- */
-class ASSIMP_API EmbedTexturesProcess : public BaseProcess {
-public:
-    /// The default class constructor.
-    EmbedTexturesProcess();
-
-    /// The class destructor.
-    virtual ~EmbedTexturesProcess();
-
-    /// Overwritten, @see BaseProcess
-    virtual bool IsActive(unsigned int pFlags) const;
-
-    /// Overwritten, @see BaseProcess
-    virtual void SetupProperties(const Importer* pImp);
-
-    /// Overwritten, @see BaseProcess
-    virtual void Execute(aiScene* pScene);
-
-private:
-    // Resolve the path and add the file content to the scene as a texture.
-    bool addTexture(aiScene* pScene, std::string path) const;
-
-private:
-    std::string mRootPath;
-};
-
-} // namespace Assimp
diff --git a/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp b/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp
deleted file mode 100644
index 50fac46dba..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FindDegenerates.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  FindDegenerates.cpp
- *  @brief Implementation of the FindDegenerates post-process step.
-*/
-
-
-
-// internal headers
-#include "ProcessHelper.h"
-#include "FindDegenerates.h"
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-
-//remove mesh at position 'index' from the scene
-static void removeMesh(aiScene* pScene, unsigned const index);
-//correct node indices to meshes and remove references to deleted mesh
-static void updateSceneGraph(aiNode* pNode, unsigned const index);
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-FindDegeneratesProcess::FindDegeneratesProcess()
-: mConfigRemoveDegenerates( false )
-, mConfigCheckAreaOfTriangle( false ){
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FindDegeneratesProcess::~FindDegeneratesProcess() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool FindDegeneratesProcess::IsActive( unsigned int pFlags) const {
-    return 0 != (pFlags & aiProcess_FindDegenerates);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup import configuration
-void FindDegeneratesProcess::SetupProperties(const Importer* pImp) {
-    // Get the current value of AI_CONFIG_PP_FD_REMOVE
-    mConfigRemoveDegenerates = (0 != pImp->GetPropertyInteger(AI_CONFIG_PP_FD_REMOVE,0));
-    mConfigCheckAreaOfTriangle = ( 0 != pImp->GetPropertyInteger(AI_CONFIG_PP_FD_CHECKAREA) );
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void FindDegeneratesProcess::Execute( aiScene* pScene) {
-    ASSIMP_LOG_DEBUG("FindDegeneratesProcess begin");
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
-    {
-        //Do not process point cloud, ExecuteOnMesh works only with faces data
-        if ((pScene->mMeshes[i]->mPrimitiveTypes != aiPrimitiveType::aiPrimitiveType_POINT) && ExecuteOnMesh(pScene->mMeshes[i])) {
-            removeMesh(pScene, i);
-            --i; //the current i is removed, do not skip the next one
-        }
-    }
-    ASSIMP_LOG_DEBUG("FindDegeneratesProcess finished");
-}
-
-static void removeMesh(aiScene* pScene, unsigned const index) {
-    //we start at index and copy the pointers one position forward
-    //save the mesh pointer to delete it later
-    auto delete_me = pScene->mMeshes[index];
-    for (unsigned i = index; i < pScene->mNumMeshes - 1; ++i) {
-        pScene->mMeshes[i] = pScene->mMeshes[i+1];
-    }
-    pScene->mMeshes[pScene->mNumMeshes - 1] = nullptr;
-    --(pScene->mNumMeshes);
-    delete delete_me;
-
-    //removing a mesh also requires updating all references to it in the scene graph
-    updateSceneGraph(pScene->mRootNode, index);
-}
-
-static void updateSceneGraph(aiNode* pNode, unsigned const index) {
-    for (unsigned i = 0; i < pNode->mNumMeshes; ++i) {
-        if (pNode->mMeshes[i] > index) {
-            --(pNode->mMeshes[i]);
-            continue;
-        }
-        if (pNode->mMeshes[i] == index) {
-            for (unsigned j = i; j < pNode->mNumMeshes -1; ++j) {
-                pNode->mMeshes[j] = pNode->mMeshes[j+1];
-            }
-            --(pNode->mNumMeshes);
-            --i;
-            continue;
-        }
-    }
-    //recurse to all children
-    for (unsigned i = 0; i < pNode->mNumChildren; ++i) {
-        updateSceneGraph(pNode->mChildren[i], index);
-    }
-}
-
-static ai_real heron( ai_real a, ai_real b, ai_real c ) {
-    ai_real s = (a + b + c) / 2;
-    ai_real area = pow((s * ( s - a ) * ( s - b ) * ( s - c ) ), (ai_real)0.5 );
-    return area;
-}
-
-static ai_real distance3D( const aiVector3D &vA, aiVector3D &vB ) {
-    const ai_real lx = ( vB.x - vA.x );
-    const ai_real ly = ( vB.y - vA.y );
-    const ai_real lz = ( vB.z - vA.z );
-    ai_real a = lx*lx + ly*ly + lz*lz;
-    ai_real d = pow( a, (ai_real)0.5 );
-
-    return d;
-}
-
-static ai_real calculateAreaOfTriangle( const aiFace& face, aiMesh* mesh ) {
-    ai_real area = 0;
-
-    aiVector3D vA( mesh->mVertices[ face.mIndices[ 0 ] ] );
-    aiVector3D vB( mesh->mVertices[ face.mIndices[ 1 ] ] );
-    aiVector3D vC( mesh->mVertices[ face.mIndices[ 2 ] ] );
-
-    ai_real a( distance3D( vA, vB ) );
-    ai_real b( distance3D( vB, vC ) );
-    ai_real c( distance3D( vC, vA ) );
-    area = heron( a, b, c );
-
-    return area;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported mesh
-bool FindDegeneratesProcess::ExecuteOnMesh( aiMesh* mesh) {
-    mesh->mPrimitiveTypes = 0;
-
-    std::vector<bool> remove_me;
-    if (mConfigRemoveDegenerates) {
-        remove_me.resize( mesh->mNumFaces, false );
-    }
-
-    unsigned int deg = 0, limit;
-    for ( unsigned int a = 0; a < mesh->mNumFaces; ++a ) {
-        aiFace& face = mesh->mFaces[a];
-        bool first = true;
-
-        // check whether the face contains degenerated entries
-        for (unsigned int i = 0; i < face.mNumIndices; ++i) {
-            // Polygons with more than 4 points are allowed to have double points, that is
-            // simulating polygons with holes just with concave polygons. However,
-            // double points may not come directly after another.
-            limit = face.mNumIndices;
-            if (face.mNumIndices > 4) {
-                limit = std::min( limit, i+2 );
-            }
-
-            for (unsigned int t = i+1; t < limit; ++t) {
-                if (mesh->mVertices[face.mIndices[ i ] ] == mesh->mVertices[ face.mIndices[ t ] ]) {
-                    // we have found a matching vertex position
-                    // remove the corresponding index from the array
-                    --face.mNumIndices;
-                    --limit;
-                    for (unsigned int m = t; m < face.mNumIndices; ++m) {
-                        face.mIndices[ m ] = face.mIndices[ m+1 ];
-                    }
-                    --t;
-
-                    // NOTE: we set the removed vertex index to an unique value
-                    // to make sure the developer gets notified when his
-                    // application attempts to access this data.
-                    face.mIndices[ face.mNumIndices ] = 0xdeadbeef;
-
-                    if(first) {
-                        ++deg;
-                        first = false;
-                    }
-
-                    if ( mConfigRemoveDegenerates ) {
-                        remove_me[ a ] = true;
-                        goto evil_jump_outside; // hrhrhrh ... yeah, this rocks baby!
-                    }
-                }
-            }
-
-            if ( mConfigCheckAreaOfTriangle ) {
-                if ( face.mNumIndices == 3 ) {
-                    ai_real area = calculateAreaOfTriangle( face, mesh );
-                    if ( area < 1e-6 ) {
-                        if ( mConfigRemoveDegenerates ) {
-                            remove_me[ a ] = true;
-                            ++deg;
-                            goto evil_jump_outside;
-                        }
-
-                        // todo: check for index which is corrupt.
-                    }
-                }
-            }
-        }
-
-        // We need to update the primitive flags array of the mesh.
-        switch (face.mNumIndices)
-        {
-        case 1u:
-            mesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-            break;
-        case 2u:
-            mesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-            break;
-        case 3u:
-            mesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-            break;
-        default:
-            mesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-            break;
-        };
-evil_jump_outside:
-        continue;
-    }
-
-    // If AI_CONFIG_PP_FD_REMOVE is true, remove degenerated faces from the import
-    if (mConfigRemoveDegenerates && deg) {
-        unsigned int n = 0;
-        for (unsigned int a = 0; a < mesh->mNumFaces; ++a)
-        {
-            aiFace& face_src = mesh->mFaces[a];
-            if (!remove_me[a]) {
-                aiFace& face_dest = mesh->mFaces[n++];
-
-                // Do a manual copy, keep the index array
-                face_dest.mNumIndices = face_src.mNumIndices;
-                face_dest.mIndices    = face_src.mIndices;
-
-                if (&face_src != &face_dest) {
-                    // clear source
-                    face_src.mNumIndices = 0;
-                    face_src.mIndices = nullptr;
-                }
-            }
-            else {
-                // Otherwise delete it if we don't need this face
-                delete[] face_src.mIndices;
-                face_src.mIndices = nullptr;
-                face_src.mNumIndices = 0;
-            }
-        }
-        // Just leave the rest of the array unreferenced, we don't care for now
-        mesh->mNumFaces = n;
-        if (!mesh->mNumFaces) {
-            //The whole mesh consists of degenerated faces
-            //signal upward, that this mesh should be deleted.
-            ASSIMP_LOG_DEBUG("FindDegeneratesProcess removed a mesh full of degenerated primitives");
-            return true;
-        }
-    }
-
-    if (deg && !DefaultLogger::isNullLogger()) {
-        ASSIMP_LOG_WARN_F( "Found ", deg, " degenerated primitives");
-    }
-    return false;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/FindDegenerates.h b/thirdparty/assimp/code/PostProcessing/FindDegenerates.h
deleted file mode 100644
index 7a15e77cf1..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FindDegenerates.h
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to search all meshes for
-  degenerated faces */
-#ifndef AI_FINDDEGENERATESPROCESS_H_INC
-#define AI_FINDDEGENERATESPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-
-class FindDegeneratesProcessTest;
-namespace Assimp    {
-
-
-// ---------------------------------------------------------------------------
-/** FindDegeneratesProcess: Searches a mesh for degenerated triangles.
-*/
-class ASSIMP_API FindDegeneratesProcess : public BaseProcess {
-public:
-    FindDegeneratesProcess();
-    ~FindDegeneratesProcess();
-
-    // -------------------------------------------------------------------
-    // Check whether step is active
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    // Execute step on a given scene
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    // Setup import settings
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    // Execute step on a given mesh
-    ///@returns true if the current mesh should be deleted, false otherwise
-    bool ExecuteOnMesh( aiMesh* mesh);
-
-    // -------------------------------------------------------------------
-    /// @brief Enable the instant removal of degenerated primitives
-    /// @param enabled  true for enabled.
-    void EnableInstantRemoval(bool enabled);
-
-    // -------------------------------------------------------------------
-    /// @brief Check whether instant removal is currently enabled
-    /// @return The instant removal state.
-    bool IsInstantRemoval() const;
-
-    // -------------------------------------------------------------------
-    /// @brief Enable the area check for triangles.
-    /// @param enabled  true for enabled.
-    void EnableAreaCheck( bool enabled );
-
-    // -------------------------------------------------------------------
-    /// @brief Check whether the area check is enabled.
-    /// @return The area check state.
-    bool isAreaCheckEnabled() const;
-
-private:
-    //! Configuration option: remove degenerates faces immediately
-    bool mConfigRemoveDegenerates;
-    //! Configuration option: check for area
-    bool mConfigCheckAreaOfTriangle;
-};
-
-inline
-void FindDegeneratesProcess::EnableInstantRemoval(bool enabled) {
-    mConfigRemoveDegenerates = enabled;
-}
-
-inline
-bool FindDegeneratesProcess::IsInstantRemoval() const {
-    return mConfigRemoveDegenerates;
-}
-
-inline
-void FindDegeneratesProcess::EnableAreaCheck( bool enabled ) {
-    mConfigCheckAreaOfTriangle = enabled;
-}
-
-inline
-bool FindDegeneratesProcess::isAreaCheckEnabled() const {
-    return mConfigCheckAreaOfTriangle;
-}
-
-} // Namespace Assimp
-
-#endif // !! AI_FINDDEGENERATESPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp b/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp
deleted file mode 100644
index 64907458a1..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.cpp
+++ /dev/null
@@ -1,277 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  FindInstancesProcess.cpp
- *  @brief Implementation of the aiProcess_FindInstances postprocessing step
-*/
-
-
-#include "FindInstancesProcess.h"
-#include <memory>
-#include <stdio.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-FindInstancesProcess::FindInstancesProcess()
-:   configSpeedFlag (false)
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FindInstancesProcess::~FindInstancesProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool FindInstancesProcess::IsActive( unsigned int pFlags) const
-{
-    // FindInstances makes absolutely no sense together with PreTransformVertices
-    // fixme: spawn error message somewhere else?
-    return 0 != (pFlags & aiProcess_FindInstances) && 0 == (pFlags & aiProcess_PreTransformVertices);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup properties for the step
-void FindInstancesProcess::SetupProperties(const Importer* pImp)
-{
-    // AI_CONFIG_FAVOUR_SPEED
-    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED,0));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Compare the bones of two meshes
-bool CompareBones(const aiMesh* orig, const aiMesh* inst)
-{
-    for (unsigned int i = 0; i < orig->mNumBones;++i) {
-        aiBone* aha = orig->mBones[i];
-        aiBone* oha = inst->mBones[i];
-
-        if (aha->mNumWeights   != oha->mNumWeights   ||
-            aha->mOffsetMatrix != oha->mOffsetMatrix) {
-            return false;
-        }
-
-        // compare weight per weight ---
-        for (unsigned int n = 0; n < aha->mNumWeights;++n) {
-            if  (aha->mWeights[n].mVertexId != oha->mWeights[n].mVertexId ||
-                (aha->mWeights[n].mWeight - oha->mWeights[n].mWeight) < 10e-3f) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Update mesh indices in the node graph
-void UpdateMeshIndices(aiNode* node, unsigned int* lookup)
-{
-    for (unsigned int n = 0; n < node->mNumMeshes;++n)
-        node->mMeshes[n] = lookup[node->mMeshes[n]];
-
-    for (unsigned int n = 0; n < node->mNumChildren;++n)
-        UpdateMeshIndices(node->mChildren[n],lookup);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void FindInstancesProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("FindInstancesProcess begin");
-    if (pScene->mNumMeshes) {
-
-        // use a pseudo hash for all meshes in the scene to quickly find
-        // the ones which are possibly equal. This step is executed early
-        // in the pipeline, so we could, depending on the file format,
-        // have several thousand small meshes. That's too much for a brute
-        // everyone-against-everyone check involving up to 10 comparisons
-        // each.
-        std::unique_ptr<uint64_t[]> hashes (new uint64_t[pScene->mNumMeshes]);
-        std::unique_ptr<unsigned int[]> remapping (new unsigned int[pScene->mNumMeshes]);
-
-        unsigned int numMeshesOut = 0;
-        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-
-            aiMesh* inst = pScene->mMeshes[i];
-            hashes[i] = GetMeshHash(inst);
-
-            // Find an appropriate epsilon 
-            // to compare position differences against
-            float epsilon = ComputePositionEpsilon(inst);
-            epsilon *= epsilon;
-
-            for (int a = i-1; a >= 0; --a) {
-                if (hashes[i] == hashes[a])
-                {
-                    aiMesh* orig = pScene->mMeshes[a];
-                    if (!orig)
-                        continue;
-
-                    // check for hash collision .. we needn't check
-                    // the vertex format, it *must* match due to the
-                    // (brilliant) construction of the hash
-                    if (orig->mNumBones       != inst->mNumBones      ||
-                        orig->mNumFaces       != inst->mNumFaces      ||
-                        orig->mNumVertices    != inst->mNumVertices   ||
-                        orig->mMaterialIndex  != inst->mMaterialIndex ||
-                        orig->mPrimitiveTypes != inst->mPrimitiveTypes)
-                        continue;
-
-                    // up to now the meshes are equal. Now compare vertex positions, normals,
-                    // tangents and bitangents using this epsilon.
-                    if (orig->HasPositions()) {
-                        if(!CompareArrays(orig->mVertices,inst->mVertices,orig->mNumVertices,epsilon))
-                            continue;
-                    }
-                    if (orig->HasNormals()) {
-                        if(!CompareArrays(orig->mNormals,inst->mNormals,orig->mNumVertices,epsilon))
-                            continue;
-                    }
-                    if (orig->HasTangentsAndBitangents()) {
-                        if (!CompareArrays(orig->mTangents,inst->mTangents,orig->mNumVertices,epsilon) ||
-                            !CompareArrays(orig->mBitangents,inst->mBitangents,orig->mNumVertices,epsilon))
-                            continue;
-                    }
-
-                    // use a constant epsilon for colors and UV coordinates
-                    static const float uvEpsilon = 10e-4f;
-                    {
-                        unsigned int j, end = orig->GetNumUVChannels();
-                        for(j = 0; j < end; ++j) {
-                            if (!orig->mTextureCoords[j]) {
-                                continue;
-                            }
-                            if(!CompareArrays(orig->mTextureCoords[j],inst->mTextureCoords[j],orig->mNumVertices,uvEpsilon)) {
-                                break;
-                            }
-                        }
-                        if (j != end) {
-                            continue;
-                        }
-                    }
-                    {
-                        unsigned int j, end = orig->GetNumColorChannels();
-                        for(j = 0; j < end; ++j) {
-                            if (!orig->mColors[j]) {
-                                continue;
-                            }
-                            if(!CompareArrays(orig->mColors[j],inst->mColors[j],orig->mNumVertices,uvEpsilon)) {
-                                break;
-                            }
-                        }
-                        if (j != end) {
-                            continue;
-                        }
-                    }
-
-                    // These two checks are actually quite expensive and almost *never* required.
-                    // Almost. That's why they're still here. But there's no reason to do them
-                    // in speed-targeted imports.
-                    if (!configSpeedFlag) {
-
-                        // It seems to be strange, but we really need to check whether the
-                        // bones are identical too. Although it's extremely unprobable
-                        // that they're not if control reaches here, we need to deal
-                        // with unprobable cases, too. It could still be that there are
-                        // equal shapes which are deformed differently.
-                        if (!CompareBones(orig,inst))
-                            continue;
-
-                        // For completeness ... compare even the index buffers for equality
-                        // face order & winding order doesn't care. Input data is in verbose format.
-                        std::unique_ptr<unsigned int[]> ftbl_orig(new unsigned int[orig->mNumVertices]);
-                        std::unique_ptr<unsigned int[]> ftbl_inst(new unsigned int[orig->mNumVertices]);
-
-                        for (unsigned int tt = 0; tt < orig->mNumFaces;++tt) {
-                            aiFace& f = orig->mFaces[tt];
-                            for (unsigned int nn = 0; nn < f.mNumIndices;++nn)
-                                ftbl_orig[f.mIndices[nn]] = tt;
-
-                            aiFace& f2 = inst->mFaces[tt];
-                            for (unsigned int nn = 0; nn < f2.mNumIndices;++nn)
-                                ftbl_inst[f2.mIndices[nn]] = tt;
-                        }
-                        if (0 != ::memcmp(ftbl_inst.get(),ftbl_orig.get(),orig->mNumVertices*sizeof(unsigned int)))
-                            continue;
-                    }
-
-                    // We're still here. Or in other words: 'inst' is an instance of 'orig'.
-                    // Place a marker in our list that we can easily update mesh indices.
-                    remapping[i] = remapping[a];
-
-                    // Delete the instanced mesh, we don't need it anymore
-                    delete inst;
-                    pScene->mMeshes[i] = NULL;
-                    break;
-                }
-            }
-
-            // If we didn't find a match for the current mesh: keep it
-            if (pScene->mMeshes[i]) {
-                remapping[i] = numMeshesOut++;
-            }
-        }
-        ai_assert(0 != numMeshesOut);
-        if (numMeshesOut != pScene->mNumMeshes) {
-
-            // Collapse the meshes array by removing all NULL entries
-            for (unsigned int real = 0, i = 0; real < numMeshesOut; ++i) {
-                if (pScene->mMeshes[i])
-                    pScene->mMeshes[real++] = pScene->mMeshes[i];
-            }
-
-            // And update the node graph with our nice lookup table
-            UpdateMeshIndices(pScene->mRootNode,remapping.get());
-
-            // write to log
-            if (!DefaultLogger::isNullLogger()) {
-                ASSIMP_LOG_INFO_F( "FindInstancesProcess finished. Found ", (pScene->mNumMeshes - numMeshesOut), " instances" );
-            }
-            pScene->mNumMeshes = numMeshesOut;
-        } else {
-            ASSIMP_LOG_DEBUG("FindInstancesProcess finished. No instanced meshes found");
-        }
-    }
-}
diff --git a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h b/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h
deleted file mode 100644
index 64b838d7cc..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FindInstancesProcess.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  FindInstancesProcess.h
- *  @brief Declares the aiProcess_FindInstances post-process step
- */
-#ifndef AI_FINDINSTANCES_H_INC
-#define AI_FINDINSTANCES_H_INC
-
-#include "Common/BaseProcess.h"
-#include "PostProcessing/ProcessHelper.h"
-
-class FindInstancesProcessTest;
-namespace Assimp    {
-
-// -------------------------------------------------------------------------------
-/** @brief Get a pseudo(!)-hash representing a mesh.
- *
- *  The hash is built from number of vertices, faces, primitive types,
- *  .... but *not* from the real mesh data. The funcction is not a perfect hash.
- *  @param in Input mesh
- *  @return Hash.
- */
-inline
-uint64_t GetMeshHash(aiMesh* in) {
-    ai_assert(nullptr != in);
-
-    // ... get an unique value representing the vertex format of the mesh
-    const unsigned int fhash = GetMeshVFormatUnique(in);
-
-    // and bake it with number of vertices/faces/bones/matidx/ptypes
-    return ((uint64_t)fhash << 32u) | ((
-        (in->mNumBones << 16u) ^  (in->mNumVertices)       ^
-        (in->mNumFaces<<4u)    ^  (in->mMaterialIndex<<15) ^
-        (in->mPrimitiveTypes<<28)) & 0xffffffff );
-}
-
-// -------------------------------------------------------------------------------
-/** @brief Perform a component-wise comparison of two arrays
- *
- *  @param first First array
- *  @param second Second array
- *  @param size Size of both arrays
- *  @param e Epsilon
- *  @return true if the arrays are identical
- */
-inline
-bool CompareArrays(const aiVector3D* first, const aiVector3D* second,
-        unsigned int size, float e) {
-    for (const aiVector3D* end = first+size; first != end; ++first,++second) {
-        if ( (*first - *second).SquareLength() >= e)
-            return false;
-    }
-    return true;
-}
-
-// and the same for colors ...
-inline bool CompareArrays(const aiColor4D* first, const aiColor4D* second,
-    unsigned int size, float e)
-{
-    for (const aiColor4D* end = first+size; first != end; ++first,++second) {
-        if ( GetColorDifference(*first,*second) >= e)
-            return false;
-    }
-    return true;
-}
-
-// ---------------------------------------------------------------------------
-/** @brief A post-processing steps to search for instanced meshes
-*/
-class FindInstancesProcess : public BaseProcess
-{
-public:
-
-    FindInstancesProcess();
-    ~FindInstancesProcess();
-
-public:
-    // -------------------------------------------------------------------
-    // Check whether step is active in given flags combination
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    // Execute step on a given scene
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    // Setup properties prior to executing the process
-    void SetupProperties(const Importer* pImp);
-
-private:
-
-    bool configSpeedFlag;
-
-}; // ! end class FindInstancesProcess
-}  // ! end namespace Assimp
-
-#endif // !! AI_FINDINSTANCES_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp b/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
deleted file mode 100644
index 016884c6e7..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.cpp
+++ /dev/null
@@ -1,423 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to search an importer's output
-    for data that is obviously invalid  */
-
-
-
-#ifndef ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
-
-// internal headers
-#include "FindInvalidDataProcess.h"
-#include "ProcessHelper.h"
-
-#include <assimp/Exceptional.h>
-#include <assimp/qnan.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-FindInvalidDataProcess::FindInvalidDataProcess()
-: configEpsilon(0.0)
-, mIgnoreTexCoods( false ){
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FindInvalidDataProcess::~FindInvalidDataProcess() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool FindInvalidDataProcess::IsActive( unsigned int pFlags) const {
-    return 0 != (pFlags & aiProcess_FindInvalidData);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup import configuration
-void FindInvalidDataProcess::SetupProperties(const Importer* pImp) {
-    // Get the current value of AI_CONFIG_PP_FID_ANIM_ACCURACY
-    configEpsilon = (0 != pImp->GetPropertyFloat(AI_CONFIG_PP_FID_ANIM_ACCURACY,0.f));
-    mIgnoreTexCoods = pImp->GetPropertyBool(AI_CONFIG_PP_FID_IGNORE_TEXTURECOORDS, false);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Update mesh references in the node graph
-void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMapping) {
-    if (node->mNumMeshes)   {
-        unsigned int out = 0;
-        for (unsigned int a = 0; a < node->mNumMeshes;++a)  {
-
-            unsigned int ref = node->mMeshes[a];
-            if (UINT_MAX != (ref = meshMapping[ref]))   {
-                node->mMeshes[out++] = ref;
-            }
-        }
-        // just let the members that are unused, that's much cheaper
-        // than a full array realloc'n'copy party ...
-        if(!(node->mNumMeshes = out))   {
-
-            delete[] node->mMeshes;
-            node->mMeshes = NULL;
-        }
-    }
-    // recursively update all children
-    for (unsigned int i = 0; i < node->mNumChildren;++i) {
-        UpdateMeshReferences(node->mChildren[i],meshMapping);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void FindInvalidDataProcess::Execute( aiScene* pScene) {
-    ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
-
-    bool out = false;
-    std::vector<unsigned int> meshMapping(pScene->mNumMeshes);
-    unsigned int real = 0;
-
-    // Process meshes
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)   {
-
-        int result;
-        if ((result = ProcessMesh( pScene->mMeshes[a])))    {
-            out = true;
-
-            if (2 == result)    {
-                // remove this mesh
-                delete pScene->mMeshes[a];
-                AI_DEBUG_INVALIDATE_PTR(pScene->mMeshes[a]);
-
-                meshMapping[a] = UINT_MAX;
-                continue;
-            }
-        }
-        pScene->mMeshes[real] = pScene->mMeshes[a];
-        meshMapping[a] = real++;
-    }
-
-    // Process animations
-    for (unsigned int a = 0; a < pScene->mNumAnimations;++a) {
-        ProcessAnimation( pScene->mAnimations[a]);
-    }
-
-
-    if (out)    {
-        if ( real != pScene->mNumMeshes)    {
-            if (!real) {
-                throw DeadlyImportError("No meshes remaining");
-            }
-
-            // we need to remove some meshes.
-            // therefore we'll also need to remove all references
-            // to them from the scenegraph
-            UpdateMeshReferences(pScene->mRootNode,meshMapping);
-            pScene->mNumMeshes = real;
-        }
-
-        ASSIMP_LOG_INFO("FindInvalidDataProcess finished. Found issues ...");
-    } else {
-        ASSIMP_LOG_DEBUG("FindInvalidDataProcess finished. Everything seems to be OK.");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-inline
-const char* ValidateArrayContents(const T* /*arr*/, unsigned int /*size*/,
-        const std::vector<bool>& /*dirtyMask*/, bool /*mayBeIdentical = false*/, bool /*mayBeZero = true*/)
-{
-    return nullptr;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <>
-inline
-const char* ValidateArrayContents<aiVector3D>(const aiVector3D* arr, unsigned int size,
-        const std::vector<bool>& dirtyMask, bool mayBeIdentical , bool mayBeZero ) {
-    bool b = false;
-    unsigned int cnt = 0;
-    for (unsigned int i = 0; i < size;++i)  {
-
-        if (dirtyMask.size() && dirtyMask[i]) {
-            continue;
-        }
-        ++cnt;
-
-        const aiVector3D& v = arr[i];
-        if (is_special_float(v.x) || is_special_float(v.y) || is_special_float(v.z))    {
-            return "INF/NAN was found in a vector component";
-        }
-        if (!mayBeZero && !v.x && !v.y && !v.z )    {
-            return "Found zero-length vector";
-        }
-        if (i && v != arr[i-1])b = true;
-    }
-    if (cnt > 1 && !b && !mayBeIdentical) {
-        return "All vectors are identical";
-    }
-    return nullptr;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-inline 
-bool ProcessArray(T*& in, unsigned int num,const char* name,
-        const std::vector<bool>& dirtyMask, bool mayBeIdentical = false, bool mayBeZero = true) {
-    const char* err = ValidateArrayContents(in,num,dirtyMask,mayBeIdentical,mayBeZero);
-    if (err)    {
-        ASSIMP_LOG_ERROR_F( "FindInvalidDataProcess fails on mesh ", name, ": ", err);
-        delete[] in;
-        in = NULL;
-        return true;
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-AI_FORCE_INLINE bool EpsilonCompare(const T& n, const T& s, ai_real epsilon);
-
-// ------------------------------------------------------------------------------------------------
-AI_FORCE_INLINE bool EpsilonCompare(ai_real n, ai_real s, ai_real epsilon) {
-    return std::fabs(n-s)>epsilon;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <>
-bool EpsilonCompare<aiVectorKey>(const aiVectorKey& n, const aiVectorKey& s, ai_real epsilon) {
-    return
-        EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
-        EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
-        EpsilonCompare(n.mValue.z,s.mValue.z,epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-template <>
-bool EpsilonCompare<aiQuatKey>(const aiQuatKey& n, const aiQuatKey& s, ai_real epsilon)   {
-    return
-        EpsilonCompare(n.mValue.x,s.mValue.x,epsilon) &&
-        EpsilonCompare(n.mValue.y,s.mValue.y,epsilon) &&
-        EpsilonCompare(n.mValue.z,s.mValue.z,epsilon) &&
-        EpsilonCompare(n.mValue.w,s.mValue.w,epsilon);
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-inline
-bool AllIdentical(T* in, unsigned int num, ai_real epsilon) {
-    if (num <= 1) {
-        return true;
-    }
-
-    if (fabs(epsilon) > 0.f) {
-        for (unsigned int i = 0; i < num-1;++i) {
-            if (!EpsilonCompare(in[i],in[i+1],epsilon)) {
-                return false;
-            }
-        }
-    } else {
-        for (unsigned int i = 0; i < num-1;++i) {
-            if (in[i] != in[i+1]) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Search an animation for invalid content
-void FindInvalidDataProcess::ProcessAnimation (aiAnimation* anim) {
-    // Process all animation channels
-    for ( unsigned int a = 0; a < anim->mNumChannels; ++a ) {
-        ProcessAnimationChannel( anim->mChannels[a]);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim) {
-    ai_assert( nullptr != anim );
-    if (anim->mNumPositionKeys == 0 && anim->mNumRotationKeys == 0 && anim->mNumScalingKeys == 0) {
-        ai_assert_entry();
-        return;
-    }
-
-    // Check whether all values in a tracks are identical - in this case
-    // we can remove al keys except one.
-    // POSITIONS
-    int i = 0;
-    if (anim->mNumPositionKeys > 1 && AllIdentical(anim->mPositionKeys,anim->mNumPositionKeys,configEpsilon)) {
-        aiVectorKey v = anim->mPositionKeys[0];
-
-        // Reallocate ... we need just ONE element, it makes no sense to reuse the array
-        delete[] anim->mPositionKeys;
-        anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = 1];
-        anim->mPositionKeys[0] = v;
-        i = 1;
-    }
-
-    // ROTATIONS
-    if (anim->mNumRotationKeys > 1 && AllIdentical(anim->mRotationKeys,anim->mNumRotationKeys,configEpsilon)) {
-        aiQuatKey v = anim->mRotationKeys[0];
-
-        // Reallocate ... we need just ONE element, it makes no sense to reuse the array
-        delete[] anim->mRotationKeys;
-        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = 1];
-        anim->mRotationKeys[0] = v;
-        i = 1;
-    }
-
-    // SCALINGS
-    if (anim->mNumScalingKeys > 1 && AllIdentical(anim->mScalingKeys,anim->mNumScalingKeys,configEpsilon)) {
-        aiVectorKey v = anim->mScalingKeys[0];
-
-        // Reallocate ... we need just ONE element, it makes no sense to reuse the array
-        delete[] anim->mScalingKeys;
-        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = 1];
-        anim->mScalingKeys[0] = v;
-        i = 1;
-    }
-    if ( 1 == i ) {
-        ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Search a mesh for invalid contents
-int FindInvalidDataProcess::ProcessMesh(aiMesh* pMesh)
-{
-    bool ret = false;
-    std::vector<bool> dirtyMask(pMesh->mNumVertices, pMesh->mNumFaces != 0);
-
-    // Ignore elements that are not referenced by vertices.
-    // (they are, for example, caused by the FindDegenerates step)
-    for (unsigned int m = 0; m < pMesh->mNumFaces; ++m) {
-        const aiFace& f = pMesh->mFaces[m];
-
-        for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-            dirtyMask[f.mIndices[i]] = false;
-        }
-    }
-
-    // Process vertex positions
-    if (pMesh->mVertices && ProcessArray(pMesh->mVertices, pMesh->mNumVertices, "positions", dirtyMask)) {
-        ASSIMP_LOG_ERROR("Deleting mesh: Unable to continue without vertex positions");
-
-        return 2;
-    }
-
-    // process texture coordinates
-    if (!mIgnoreTexCoods) {
-        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS && pMesh->mTextureCoords[i]; ++i) {
-            if (ProcessArray(pMesh->mTextureCoords[i], pMesh->mNumVertices, "uvcoords", dirtyMask)) {
-                pMesh->mNumUVComponents[i] = 0;
-
-                // delete all subsequent texture coordinate sets.
-                for (unsigned int a = i + 1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
-                    delete[] pMesh->mTextureCoords[a];
-                    pMesh->mTextureCoords[a] = NULL;
-                    pMesh->mNumUVComponents[a] = 0;
-                }
-
-                ret = true;
-            }
-        }
-    }
-
-    // -- we don't validate vertex colors, it's difficult to say whether
-    // they are invalid or not.
-
-    // Normals and tangents are undefined for point and line faces.
-    if (pMesh->mNormals || pMesh->mTangents)    {
-
-        if (aiPrimitiveType_POINT & pMesh->mPrimitiveTypes ||
-            aiPrimitiveType_LINE  & pMesh->mPrimitiveTypes)
-        {
-            if (aiPrimitiveType_TRIANGLE & pMesh->mPrimitiveTypes ||
-                aiPrimitiveType_POLYGON  & pMesh->mPrimitiveTypes)
-            {
-                // We need to update the lookup-table
-                for (unsigned int m = 0; m < pMesh->mNumFaces;++m) {
-                    const aiFace& f = pMesh->mFaces[ m ];
-
-                    if (f.mNumIndices < 3)  {
-                        dirtyMask[f.mIndices[0]] = true;
-                        if (f.mNumIndices == 2) {
-                            dirtyMask[f.mIndices[1]] = true;
-                        }
-                    }
-                }
-            }
-            // Normals, tangents and bitangents are undefined for
-            // the whole mesh (and should not even be there)
-            else {
-                return ret;
-            }
-        }
-
-        // Process mesh normals
-        if (pMesh->mNormals && ProcessArray(pMesh->mNormals,pMesh->mNumVertices,
-            "normals",dirtyMask,true,false))
-            ret = true;
-
-        // Process mesh tangents
-        if (pMesh->mTangents && ProcessArray(pMesh->mTangents,pMesh->mNumVertices,"tangents",dirtyMask))    {
-            delete[] pMesh->mBitangents; pMesh->mBitangents = NULL;
-            ret = true;
-        }
-
-        // Process mesh bitangents
-        if (pMesh->mBitangents && ProcessArray(pMesh->mBitangents,pMesh->mNumVertices,"bitangents",dirtyMask))  {
-            delete[] pMesh->mTangents; pMesh->mTangents = NULL;
-            ret = true;
-        }
-    }
-    return ret ? 1 : 0;
-}
-
-#endif // !! ASSIMP_BUILD_NO_FINDINVALIDDATA_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h b/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h
deleted file mode 100644
index ce7375f34f..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FindInvalidDataProcess.h
+++ /dev/null
@@ -1,106 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to search an importer's output
- *   for data that is obviously invalid
- */
-#ifndef AI_FINDINVALIDDATA_H_INC
-#define AI_FINDINVALIDDATA_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/types.h>
-#include <assimp/anim.h>
-
-struct aiMesh;
-
-class FindInvalidDataProcessTest;
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** The FindInvalidData post-processing step. It searches the mesh data
- *  for parts that are obviously invalid and removes them.
- *
- *  Originally this was a workaround for some models written by Blender
- *  which have zero normal vectors. */
-class ASSIMP_API FindInvalidDataProcess : public BaseProcess {
-public:
-    FindInvalidDataProcess();
-    ~FindInvalidDataProcess();
-
-    // -------------------------------------------------------------------
-    //
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    // Setup import settings
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    // Run the step
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    /** Executes the post-processing step on the given mesh
-     * @param pMesh The mesh to process.
-     * @return 0 - nothing, 1 - removed sth, 2 - please delete me  */
-    int ProcessMesh( aiMesh* pMesh);
-
-    // -------------------------------------------------------------------
-    /** Executes the post-processing step on the given animation
-     * @param anim The animation to process.  */
-    void ProcessAnimation (aiAnimation* anim);
-
-    // -------------------------------------------------------------------
-    /** Executes the post-processing step on the given anim channel
-     * @param anim The animation channel to process.*/
-    void ProcessAnimationChannel (aiNodeAnim* anim);
-
-private:
-    ai_real configEpsilon;
-    bool mIgnoreTexCoods;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_AI_FINDINVALIDDATA_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp b/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp
deleted file mode 100644
index bbbe6899b4..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.cpp
+++ /dev/null
@@ -1,184 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to invert
- * all normals in meshes with infacing normals.
- */
-
-// internal headers
-#include "FixNormalsStep.h"
-#include <assimp/StringUtils.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <stdio.h>
-
-
-using namespace Assimp;
-
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-FixInfacingNormalsProcess::FixInfacingNormalsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-FixInfacingNormalsProcess::~FixInfacingNormalsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool FixInfacingNormalsProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_FixInfacingNormals) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void FixInfacingNormalsProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("FixInfacingNormalsProcess begin");
-
-    bool bHas( false );
-    for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-        if (ProcessMesh(pScene->mMeshes[a], a)) {
-            bHas = true;
-        }
-    }
-
-    if (bHas) {
-        ASSIMP_LOG_DEBUG("FixInfacingNormalsProcess finished. Found issues.");
-    } else {
-        ASSIMP_LOG_DEBUG("FixInfacingNormalsProcess finished. No changes to the scene.");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Apply the step to the mesh
-bool FixInfacingNormalsProcess::ProcessMesh( aiMesh* pcMesh, unsigned int index)
-{
-    ai_assert(nullptr != pcMesh);
-
-    // Nothing to do if there are no model normals
-    if (!pcMesh->HasNormals()) {
-        return false;
-    }
-
-    // Compute the bounding box of both the model vertices + normals and
-    // the unmodified model vertices. Then check whether the first BB
-    // is smaller than the second. In this case we can assume that the
-    // normals need to be flipped, although there are a few special cases ..
-    // convex, concave, planar models ...
-
-    aiVector3D vMin0 (1e10f,1e10f,1e10f);
-    aiVector3D vMin1 (1e10f,1e10f,1e10f);
-    aiVector3D vMax0 (-1e10f,-1e10f,-1e10f);
-    aiVector3D vMax1 (-1e10f,-1e10f,-1e10f);
-
-    for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
-    {
-        vMin1.x = std::min(vMin1.x,pcMesh->mVertices[i].x);
-        vMin1.y = std::min(vMin1.y,pcMesh->mVertices[i].y);
-        vMin1.z = std::min(vMin1.z,pcMesh->mVertices[i].z);
-
-        vMax1.x = std::max(vMax1.x,pcMesh->mVertices[i].x);
-        vMax1.y = std::max(vMax1.y,pcMesh->mVertices[i].y);
-        vMax1.z = std::max(vMax1.z,pcMesh->mVertices[i].z);
-
-        const aiVector3D vWithNormal = pcMesh->mVertices[i] + pcMesh->mNormals[i];
-
-        vMin0.x = std::min(vMin0.x,vWithNormal.x);
-        vMin0.y = std::min(vMin0.y,vWithNormal.y);
-        vMin0.z = std::min(vMin0.z,vWithNormal.z);
-
-        vMax0.x = std::max(vMax0.x,vWithNormal.x);
-        vMax0.y = std::max(vMax0.y,vWithNormal.y);
-        vMax0.z = std::max(vMax0.z,vWithNormal.z);
-    }
-
-    const float fDelta0_x = (vMax0.x - vMin0.x);
-    const float fDelta0_y = (vMax0.y - vMin0.y);
-    const float fDelta0_z = (vMax0.z - vMin0.z);
-
-    const float fDelta1_x = (vMax1.x - vMin1.x);
-    const float fDelta1_y = (vMax1.y - vMin1.y);
-    const float fDelta1_z = (vMax1.z - vMin1.z);
-
-    // Check whether the boxes are overlapping
-    if ((fDelta0_x > 0.0f) != (fDelta1_x > 0.0f))return false;
-    if ((fDelta0_y > 0.0f) != (fDelta1_y > 0.0f))return false;
-    if ((fDelta0_z > 0.0f) != (fDelta1_z > 0.0f))return false;
-
-    // Check whether this is a planar surface
-    const float fDelta1_yz = fDelta1_y * fDelta1_z;
-
-    if (fDelta1_x < 0.05f * std::sqrt( fDelta1_yz ))return false;
-    if (fDelta1_y < 0.05f * std::sqrt( fDelta1_z * fDelta1_x ))return false;
-    if (fDelta1_z < 0.05f * std::sqrt( fDelta1_y * fDelta1_x ))return false;
-
-    // now compare the volumes of the bounding boxes
-    if (std::fabs(fDelta0_x * fDelta0_y * fDelta0_z) < std::fabs(fDelta1_x * fDelta1_yz)) {
-        if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_INFO_F("Mesh ", index, ": Normals are facing inwards (or the mesh is planar)", index);
-        }
-
-        // Invert normals
-        for (unsigned int i = 0; i < pcMesh->mNumVertices;++i)
-            pcMesh->mNormals[i] *= -1.0f;
-
-        // ... and flip faces
-        for (unsigned int i = 0; i < pcMesh->mNumFaces;++i)
-        {
-            aiFace& face = pcMesh->mFaces[i];
-            for( unsigned int b = 0; b < face.mNumIndices / 2; b++)
-                std::swap( face.mIndices[b], face.mIndices[ face.mNumIndices - 1 - b]);
-        }
-        return true;
-    }
-    return false;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h b/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h
deleted file mode 100644
index f60ce596a4..0000000000
--- a/thirdparty/assimp/code/PostProcessing/FixNormalsStep.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-
-/** @file Defines a post processing step to fix infacing normals */
-#ifndef AI_FIXNORMALSPROCESS_H_INC
-#define AI_FIXNORMALSPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-struct aiMesh;
-
-namespace Assimp
-{
-
-// ---------------------------------------------------------------------------
-/** The FixInfacingNormalsProcess tries to determine whether the normal
- * vectors of an object are facing inwards. In this case they will be
- * flipped.
- */
-class FixInfacingNormalsProcess : public BaseProcess {
-public:
-    FixInfacingNormalsProcess();
-    ~FixInfacingNormalsProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-     * @param pFlags The processing flags the importer was called with. A bitwise
-     *   combination of #aiPostProcessSteps.
-     * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-protected:
-
-    // -------------------------------------------------------------------
-    /** Executes the step on the given mesh
-     * @param pMesh The mesh to process.
-     */
-    bool ProcessMesh( aiMesh* pMesh, unsigned int index);
-};
-
-} // end of namespace Assimp
-
-#endif // AI_FIXNORMALSPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp b/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
deleted file mode 100644
index c013454fc3..0000000000
--- a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.cpp
+++ /dev/null
@@ -1,115 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS
-
-#include "PostProcessing/GenBoundingBoxesProcess.h"
-
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-
-namespace Assimp {
-
-GenBoundingBoxesProcess::GenBoundingBoxesProcess()
-: BaseProcess() {
-
-}
-
-GenBoundingBoxesProcess::~GenBoundingBoxesProcess() {
-    // empty
-}
-
-bool GenBoundingBoxesProcess::IsActive(unsigned int pFlags) const {
-    return 0 != ( pFlags & aiProcess_GenBoundingBoxes );
-}
-
-void checkMesh(aiMesh* mesh, aiVector3D& min, aiVector3D& max) {
-    ai_assert(nullptr != mesh);
-
-    if (0 == mesh->mNumVertices) {
-        return;
-    }
-
-    for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
-        const aiVector3D &pos = mesh->mVertices[i];
-        if (pos.x < min.x) {
-            min.x = pos.x;
-        }
-        if (pos.y < min.y) {
-            min.y = pos.y;
-        }
-        if (pos.z < min.z) {
-            min.z = pos.z;
-        }
-
-        if (pos.x > max.x) {
-            max.x = pos.x;
-        }
-        if (pos.y > max.y) {
-            max.y = pos.y;
-        }
-        if (pos.z > max.z) {
-            max.z = pos.z;
-        }
-    }
-}
-
-void GenBoundingBoxesProcess::Execute(aiScene* pScene) {
-    if (nullptr == pScene) {
-        return;
-    }
-
-    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        aiMesh* mesh = pScene->mMeshes[i];
-        if (nullptr == mesh) {
-            continue;
-        }
-
-        aiVector3D min(999999, 999999, 999999), max(-999999, -999999, -999999);
-        checkMesh(mesh, min, max);
-        mesh->mAABB.mMin = min;
-        mesh->mAABB.mMax = max;
-    }
-}
-
-} // Namespace Assimp
-
-#endif // ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h b/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
deleted file mode 100644
index 4b43c82a42..0000000000
--- a/thirdparty/assimp/code/PostProcessing/GenBoundingBoxesProcess.h
+++ /dev/null
@@ -1,76 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Defines a post-processing step to generate Axis-aligned bounding
- *        volumes for all meshes.
- */
-
-#pragma once
-
-#ifndef AI_GENBOUNDINGBOXESPROCESS_H_INC
-#define AI_GENBOUNDINGBOXESPROCESS_H_INC
-
-#ifndef ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS
-
-#include "Common/BaseProcess.h"
-
-namespace Assimp {
-
-/** Post-processing process to find axis-aligned bounding volumes for amm meshes
- *  used in a scene
- */
-class ASSIMP_API GenBoundingBoxesProcess : public BaseProcess {
-public:
-    /// The class constructor.
-    GenBoundingBoxesProcess();
-    /// The class destructor.
-    ~GenBoundingBoxesProcess();
-    /// Will return true, if aiProcess_GenBoundingBoxes is defined.
-    bool IsActive(unsigned int pFlags) const override;
-    /// The execution callback.
-    void Execute(aiScene* pScene) override;
-};
-
-} // Namespace Assimp
-
-#endif // #ifndef ASSIMP_BUILD_NO_GENBOUNDINGBOXES_PROCESS
-
-#endif // AI_GENBOUNDINGBOXESPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp b/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
deleted file mode 100644
index 028334dec7..0000000000
--- a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.cpp
+++ /dev/null
@@ -1,146 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to generate face
-* normals for all imported faces.
-*/
-
-
-#include "GenFaceNormalsProcess.h"
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Exceptional.h>
-#include <assimp/qnan.h>
-
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-GenFaceNormalsProcess::GenFaceNormalsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-GenFaceNormalsProcess::~GenFaceNormalsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool GenFaceNormalsProcess::IsActive( unsigned int pFlags) const {
-    force_ = (pFlags & aiProcess_ForceGenNormals) != 0;
-    return  (pFlags & aiProcess_GenNormals) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void GenFaceNormalsProcess::Execute( aiScene* pScene) {
-    ASSIMP_LOG_DEBUG("GenFaceNormalsProcess begin");
-
-    if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
-        throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
-    }
-
-    bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)   {
-        if(this->GenMeshFaceNormals( pScene->mMeshes[a])) {
-            bHas = true;
-        }
-    }
-    if (bHas)   {
-        ASSIMP_LOG_INFO("GenFaceNormalsProcess finished. "
-            "Face normals have been calculated");
-    } else {
-        ASSIMP_LOG_DEBUG("GenFaceNormalsProcess finished. "
-            "Normals are already there");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-bool GenFaceNormalsProcess::GenMeshFaceNormals (aiMesh* pMesh)
-{
-    if (NULL != pMesh->mNormals) {
-        if (force_) delete[] pMesh->mNormals;
-        else return false;
-    }
-
-    // If the mesh consists of lines and/or points but not of
-    // triangles or higher-order polygons the normal vectors
-    // are undefined.
-    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))   {
-        ASSIMP_LOG_INFO("Normal vectors are undefined for line and point meshes");
-        return false;
-    }
-
-    // allocate an array to hold the output normals
-    pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-    const float qnan = get_qnan();
-
-    // iterate through all faces and compute per-face normals but store them per-vertex.
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
-        const aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices < 3)   {
-            // either a point or a line -> no well-defined normal vector
-            for (unsigned int i = 0;i < face.mNumIndices;++i) {
-                pMesh->mNormals[face.mIndices[i]] = aiVector3D(qnan);
-            }
-            continue;
-        }
-
-        const aiVector3D* pV1 = &pMesh->mVertices[face.mIndices[0]];
-        const aiVector3D* pV2 = &pMesh->mVertices[face.mIndices[1]];
-        const aiVector3D* pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices-1]];
-        const aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).NormalizeSafe();
-
-        for (unsigned int i = 0;i < face.mNumIndices;++i) {
-            pMesh->mNormals[face.mIndices[i]] = vNor;
-        }
-    }
-    return true;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h b/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h
deleted file mode 100644
index c641fd6353..0000000000
--- a/thirdparty/assimp/code/PostProcessing/GenFaceNormalsProcess.h
+++ /dev/null
@@ -1,87 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to compute face normals for all loaded faces*/
-#ifndef AI_GENFACENORMALPROCESS_H_INC
-#define AI_GENFACENORMALPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-#include <assimp/mesh.h>
-
-namespace Assimp
-{
-
-// ---------------------------------------------------------------------------
-/** The GenFaceNormalsProcess computes face normals for all faces of all meshes
-*/
-class ASSIMP_API_WINONLY GenFaceNormalsProcess : public BaseProcess
-{
-public:
-
-    GenFaceNormalsProcess();
-    ~GenFaceNormalsProcess();
-
-public:
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-    * @param pFlags The processing flags the importer was called with. A bitwise
-    *   combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-
-private:
-    bool GenMeshFaceNormals(aiMesh* pcMesh);
-    mutable bool force_ = false;
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_GENFACENORMALPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp b/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
deleted file mode 100644
index 3f6c2f86bd..0000000000
--- a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.cpp
+++ /dev/null
@@ -1,239 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to generate face
-* normals for all imported faces.
-*/
-
-
-
-// internal headers
-#include "GenVertexNormalsProcess.h"
-#include "ProcessHelper.h"
-#include <assimp/Exceptional.h>
-#include <assimp/qnan.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-GenVertexNormalsProcess::GenVertexNormalsProcess()
-: configMaxAngle( AI_DEG_TO_RAD( 175.f ) ) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-GenVertexNormalsProcess::~GenVertexNormalsProcess() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool GenVertexNormalsProcess::IsActive( unsigned int pFlags) const
-{
-    force_ = (pFlags & aiProcess_ForceGenNormals) != 0;
-    return (pFlags & aiProcess_GenSmoothNormals) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void GenVertexNormalsProcess::SetupProperties(const Importer* pImp)
-{
-    // Get the current value of the AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE property
-    configMaxAngle = pImp->GetPropertyFloat(AI_CONFIG_PP_GSN_MAX_SMOOTHING_ANGLE,(ai_real)175.0);
-    configMaxAngle = AI_DEG_TO_RAD(std::max(std::min(configMaxAngle,(ai_real)175.0),(ai_real)0.0));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void GenVertexNormalsProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("GenVertexNormalsProcess begin");
-
-    if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
-        throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
-    }
-
-    bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-        if(GenMeshVertexNormals( pScene->mMeshes[a],a))
-            bHas = true;
-    }
-
-    if (bHas)   {
-        ASSIMP_LOG_INFO("GenVertexNormalsProcess finished. "
-            "Vertex normals have been calculated");
-    } else {
-        ASSIMP_LOG_DEBUG("GenVertexNormalsProcess finished. "
-            "Normals are already there");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int meshIndex)
-{
-    if (NULL != pMesh->mNormals) {
-        if (force_) delete[] pMesh->mNormals;
-        else return false;
-    }
-
-    // If the mesh consists of lines and/or points but not of
-    // triangles or higher-order polygons the normal vectors
-    // are undefined.
-    if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))
-    {
-        ASSIMP_LOG_INFO("Normal vectors are undefined for line and point meshes");
-        return false;
-    }
-
-    // Allocate the array to hold the output normals
-    const float qnan = std::numeric_limits<ai_real>::quiet_NaN();
-    pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-
-    // Compute per-face normals but store them per-vertex
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        const aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices < 3)
-        {
-            // either a point or a line -> no normal vector
-            for (unsigned int i = 0;i < face.mNumIndices;++i) {
-                pMesh->mNormals[face.mIndices[i]] = aiVector3D(qnan);
-            }
-
-            continue;
-        }
-
-        const aiVector3D* pV1 = &pMesh->mVertices[face.mIndices[0]];
-        const aiVector3D* pV2 = &pMesh->mVertices[face.mIndices[1]];
-        const aiVector3D* pV3 = &pMesh->mVertices[face.mIndices[face.mNumIndices-1]];
-        const aiVector3D vNor = ((*pV2 - *pV1) ^ (*pV3 - *pV1)).NormalizeSafe();
-
-        for (unsigned int i = 0;i < face.mNumIndices;++i) {
-            pMesh->mNormals[face.mIndices[i]] = vNor;
-        }
-    }
-
-    // Set up a SpatialSort to quickly find all vertices close to a given position
-    // check whether we can reuse the SpatialSort of a previous step.
-    SpatialSort* vertexFinder = NULL;
-    SpatialSort  _vertexFinder;
-    ai_real posEpsilon = ai_real( 1e-5 );
-    if (shared) {
-        std::vector<std::pair<SpatialSort,ai_real> >* avf;
-        shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);
-        if (avf)
-        {
-            std::pair<SpatialSort,ai_real>& blubb = avf->operator [] (meshIndex);
-            vertexFinder = &blubb.first;
-            posEpsilon = blubb.second;
-        }
-    }
-    if (!vertexFinder)  {
-        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof( aiVector3D));
-        vertexFinder = &_vertexFinder;
-        posEpsilon = ComputePositionEpsilon(pMesh);
-    }
-    std::vector<unsigned int> verticesFound;
-    aiVector3D* pcNew = new aiVector3D[pMesh->mNumVertices];
-
-    if (configMaxAngle >= AI_DEG_TO_RAD( 175.f ))   {
-        // There is no angle limit. Thus all vertices with positions close
-        // to each other will receive the same vertex normal. This allows us
-        // to optimize the whole algorithm a little bit ...
-        std::vector<bool> abHad(pMesh->mNumVertices,false);
-        for (unsigned int i = 0; i < pMesh->mNumVertices;++i)   {
-            if (abHad[i]) {
-                continue;
-            }
-
-            // Get all vertices that share this one ...
-            vertexFinder->FindPositions( pMesh->mVertices[i], posEpsilon, verticesFound);
-
-            aiVector3D pcNor;
-            for (unsigned int a = 0; a < verticesFound.size(); ++a) {
-                const aiVector3D& v = pMesh->mNormals[verticesFound[a]];
-                if (is_not_qnan(v.x))pcNor += v;
-            }
-            pcNor.NormalizeSafe();
-
-            // Write the smoothed normal back to all affected normals
-            for (unsigned int a = 0; a < verticesFound.size(); ++a)
-            {
-                unsigned int vidx = verticesFound[a];
-                pcNew[vidx] = pcNor;
-                abHad[vidx] = true;
-            }
-        }
-    }
-    // Slower code path if a smooth angle is set. There are many ways to achieve
-    // the effect, this one is the most straightforward one.
-    else    {
-        const ai_real fLimit = std::cos(configMaxAngle);
-        for (unsigned int i = 0; i < pMesh->mNumVertices;++i)   {
-            // Get all vertices that share this one ...
-            vertexFinder->FindPositions( pMesh->mVertices[i] , posEpsilon, verticesFound);
-
-            aiVector3D vr = pMesh->mNormals[i];
-
-            aiVector3D pcNor;
-            for (unsigned int a = 0; a < verticesFound.size(); ++a) {
-                aiVector3D v = pMesh->mNormals[verticesFound[a]];
-
-                // Check whether the angle between the two normals is not too large.
-                // Skip the angle check on our own normal to avoid false negatives
-                // (v*v is not guaranteed to be 1.0 for all unit vectors v)
-                if (is_not_qnan(v.x) && (verticesFound[a] == i || (v * vr >= fLimit)))
-                    pcNor += v;
-            }
-            pcNew[i] = pcNor.NormalizeSafe();
-        }
-    }
-
-    delete[] pMesh->mNormals;
-    pMesh->mNormals = pcNew;
-
-    return true;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h b/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h
deleted file mode 100644
index 2ceee17e85..0000000000
--- a/thirdparty/assimp/code/PostProcessing/GenVertexNormalsProcess.h
+++ /dev/null
@@ -1,111 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to compute vertex normals
-    for all loaded vertizes */
-#ifndef AI_GENVERTEXNORMALPROCESS_H_INC
-#define AI_GENVERTEXNORMALPROCESS_H_INC
-
-#include "Common/assbin_chunks.h"
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-
-// Forward declarations
-class GenNormalsTest;
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** The GenFaceNormalsProcess computes vertex normals for all vertices
-*/
-class ASSIMP_API GenVertexNormalsProcess : public BaseProcess {
-public:
-    GenVertexNormalsProcess();
-    ~GenVertexNormalsProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag.
-    * @param pFlags The processing flags the importer was called with.
-    *   A bitwise combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields,
-    *   false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-
-    // setter for configMaxAngle
-    inline void SetMaxSmoothAngle(ai_real f) {
-        configMaxAngle =f;
-    }
-
-    // -------------------------------------------------------------------
-    /** Computes normals for a specific mesh
-    *  @param pcMesh Mesh
-    *  @param meshIndex Index of the mesh
-    *  @return true if vertex normals have been computed
-    */
-    bool GenMeshVertexNormals (aiMesh* pcMesh, unsigned int meshIndex);
-
-private:
-    /** Configuration option: maximum smoothing angle, in radians*/
-    ai_real configMaxAngle;
-    mutable bool force_ = false;
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_GENVERTEXNORMALPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp b/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp
deleted file mode 100644
index d0a016fa42..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.cpp
+++ /dev/null
@@ -1,379 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to improve the cache locality of a mesh.
- * <br>
- * The algorithm is roughly basing on this paper:
- * http://www.cs.princeton.edu/gfx/pubs/Sander_2007_%3ETR/tipsy.pdf
- *   .. although overdraw reduction isn't implemented yet ...
- */
-
-// internal headers
-#include "PostProcessing/ImproveCacheLocality.h"
-#include "Common/VertexTriangleAdjacency.h"
-
-#include <assimp/StringUtils.h>
-#include <assimp/postprocess.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <stdio.h>
-#include <stack>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-ImproveCacheLocalityProcess::ImproveCacheLocalityProcess()
-: mConfigCacheDepth(PP_ICL_PTCACHE_SIZE) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-ImproveCacheLocalityProcess::~ImproveCacheLocalityProcess() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool ImproveCacheLocalityProcess::IsActive( unsigned int pFlags) const {
-    return (pFlags & aiProcess_ImproveCacheLocality) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration
-void ImproveCacheLocalityProcess::SetupProperties(const Importer* pImp) {
-    // AI_CONFIG_PP_ICL_PTCACHE_SIZE controls the target cache size for the optimizer
-    mConfigCacheDepth = pImp->GetPropertyInteger(AI_CONFIG_PP_ICL_PTCACHE_SIZE,PP_ICL_PTCACHE_SIZE);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void ImproveCacheLocalityProcess::Execute( aiScene* pScene) {
-    if (!pScene->mNumMeshes) {
-        ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess skipped; there are no meshes");
-        return;
-    }
-
-    ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess begin");
-
-    float out = 0.f;
-    unsigned int numf = 0, numm = 0;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a ){
-        const float res = ProcessMesh( pScene->mMeshes[a],a);
-        if (res) {
-            numf += pScene->mMeshes[a]->mNumFaces;
-            out  += res;
-            ++numm;
-        }
-    }
-    if (!DefaultLogger::isNullLogger()) {
-        if (numf > 0) {
-            ASSIMP_LOG_INFO_F("Cache relevant are ", numm, " meshes (", numf, " faces). Average output ACMR is ", out / numf);
-        }
-        ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess finished. ");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Improves the cache coherency of a specific mesh
-ai_real ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshNum) {
-    // TODO: rewrite this to use std::vector or boost::shared_array
-    ai_assert(nullptr != pMesh);
-
-    // Check whether the input data is valid
-    // - there must be vertices and faces
-    // - all faces must be triangulated or we can't operate on them
-    if (!pMesh->HasFaces() || !pMesh->HasPositions())
-        return static_cast<ai_real>(0.f);
-
-    if (pMesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE) {
-        ASSIMP_LOG_ERROR("This algorithm works on triangle meshes only");
-        return static_cast<ai_real>(0.f);
-    }
-
-    if(pMesh->mNumVertices <= mConfigCacheDepth) {
-        return static_cast<ai_real>(0.f);
-    }
-
-    ai_real fACMR = 3.f;
-    const aiFace* const pcEnd = pMesh->mFaces+pMesh->mNumFaces;
-
-    // Input ACMR is for logging purposes only
-    if (!DefaultLogger::isNullLogger())     {
-
-        unsigned int* piFIFOStack = new unsigned int[mConfigCacheDepth];
-        memset(piFIFOStack,0xff,mConfigCacheDepth*sizeof(unsigned int));
-        unsigned int* piCur = piFIFOStack;
-        const unsigned int* const piCurEnd = piFIFOStack + mConfigCacheDepth;
-
-        // count the number of cache misses
-        unsigned int iCacheMisses = 0;
-        for (const aiFace* pcFace = pMesh->mFaces;pcFace != pcEnd;++pcFace) {
-            for (unsigned int qq = 0; qq < 3;++qq) {
-                bool bInCache = false;
-                for (unsigned int* pp = piFIFOStack;pp < piCurEnd;++pp) {
-                    if (*pp == pcFace->mIndices[qq])    {
-                        // the vertex is in cache
-                        bInCache = true;
-                        break;
-                    }
-                }
-                if (!bInCache)  {
-                    ++iCacheMisses;
-                    if (piCurEnd == piCur) {
-                        piCur = piFIFOStack;
-                    }
-                    *piCur++ = pcFace->mIndices[qq];
-                }
-            }
-        }
-        delete[] piFIFOStack;
-        fACMR = (ai_real) iCacheMisses / pMesh->mNumFaces;
-        if (3.0 == fACMR)   {
-            char szBuff[128]; // should be sufficiently large in every case
-
-            // the JoinIdenticalVertices process has not been executed on this
-            // mesh, otherwise this value would normally be at least minimally
-            // smaller than 3.0 ...
-            ai_snprintf(szBuff,128,"Mesh %u: Not suitable for vcache optimization",meshNum);
-            ASSIMP_LOG_WARN(szBuff);
-            return static_cast<ai_real>(0.f);
-        }
-    }
-
-    // first we need to build a vertex-triangle adjacency list
-    VertexTriangleAdjacency adj(pMesh->mFaces,pMesh->mNumFaces, pMesh->mNumVertices,true);
-
-    // build a list to store per-vertex caching time stamps
-    unsigned int* const piCachingStamps = new unsigned int[pMesh->mNumVertices];
-    memset(piCachingStamps,0x0,pMesh->mNumVertices*sizeof(unsigned int));
-
-    // allocate an empty output index buffer. We store the output indices in one large array.
-    // Since the number of triangles won't change the input faces can be reused. This is how
-    // we save thousands of redundant mini allocations for aiFace::mIndices
-    const unsigned int iIdxCnt = pMesh->mNumFaces*3;
-    unsigned int* const piIBOutput = new unsigned int[iIdxCnt];
-    unsigned int* piCSIter = piIBOutput;
-
-    // allocate the flag array to hold the information
-    // whether a face has already been emitted or not
-    std::vector<bool> abEmitted(pMesh->mNumFaces,false);
-
-    // dead-end vertex index stack
-    std::stack<unsigned int, std::vector<unsigned int> > sDeadEndVStack;
-
-    // create a copy of the piNumTriPtr buffer
-    unsigned int* const piNumTriPtr = adj.mLiveTriangles;
-    const std::vector<unsigned int> piNumTriPtrNoModify(piNumTriPtr, piNumTriPtr + pMesh->mNumVertices);
-
-    // get the largest number of referenced triangles and allocate the "candidate buffer"
-    unsigned int iMaxRefTris = 0; {
-        const unsigned int* piCur = adj.mLiveTriangles;
-        const unsigned int* const piCurEnd = adj.mLiveTriangles+pMesh->mNumVertices;
-        for (;piCur != piCurEnd;++piCur) {
-            iMaxRefTris = std::max(iMaxRefTris,*piCur);
-        }
-    }
-    ai_assert(iMaxRefTris > 0);
-    unsigned int* piCandidates = new unsigned int[iMaxRefTris*3];
-    unsigned int iCacheMisses = 0;
-
-    // ...................................................................................
-    /** PSEUDOCODE for the algorithm
-
-        A = Build-Adjacency(I) Vertex-triangle adjacency
-        L = Get-Triangle-Counts(A) Per-vertex live triangle counts
-        C = Zero(Vertex-Count(I)) Per-vertex caching time stamps
-        D = Empty-Stack() Dead-end vertex stack
-        E = False(Triangle-Count(I)) Per triangle emitted flag
-        O = Empty-Index-Buffer() Empty output buffer
-        f = 0 Arbitrary starting vertex
-        s = k+1, i = 1 Time stamp and cursor
-        while f >= 0 For all valid fanning vertices
-            N = Empty-Set() 1-ring of next candidates
-            for each Triangle t in Neighbors(A, f)
-                if !Emitted(E,t)
-                    for each Vertex v in t
-                        Append(O,v) Output vertex
-                        Push(D,v) Add to dead-end stack
-                        Insert(N,v) Register as candidate
-                        L[v] = L[v]-1 Decrease live triangle count
-                        if s-C[v] > k If not in cache
-                            C[v] = s Set time stamp
-                            s = s+1 Increment time stamp
-                    E[t] = true Flag triangle as emitted
-            Select next fanning vertex
-            f = Get-Next-Vertex(I,i,k,N,C,s,L,D)
-        return O
-        */
-    // ...................................................................................
-
-    int ivdx = 0;
-    int ics = 1;
-    int iStampCnt = mConfigCacheDepth+1;
-    while (ivdx >= 0)   {
-
-        unsigned int icnt = piNumTriPtrNoModify[ivdx];
-        unsigned int* piList = adj.GetAdjacentTriangles(ivdx);
-        unsigned int* piCurCandidate = piCandidates;
-
-        // get all triangles in the neighborhood
-        for (unsigned int tri = 0; tri < icnt;++tri)    {
-
-            // if they have not yet been emitted, add them to the output IB
-            const unsigned int fidx = *piList++;
-            if (!abEmitted[fidx])   {
-
-                // so iterate through all vertices of the current triangle
-                const aiFace* pcFace = &pMesh->mFaces[ fidx ];
-                unsigned nind = pcFace->mNumIndices;
-                for (unsigned ind = 0; ind < nind; ind++) {
-                    unsigned dp = pcFace->mIndices[ind];
-
-                    // the current vertex won't have any free triangles after this step
-                    if (ivdx != (int)dp) {
-                        // append the vertex to the dead-end stack
-                        sDeadEndVStack.push(dp);
-
-                        // register as candidate for the next step
-                        *piCurCandidate++ = dp;
-
-                        // decrease the per-vertex triangle counts
-                        piNumTriPtr[dp]--;
-                    }
-
-                    // append the vertex to the output index buffer
-                    *piCSIter++ = dp;
-
-                    // if the vertex is not yet in cache, set its cache count
-                    if (iStampCnt-piCachingStamps[dp] > mConfigCacheDepth) {
-                        piCachingStamps[dp] = iStampCnt++;
-                        ++iCacheMisses;
-                    }
-                }
-                // flag triangle as emitted
-                abEmitted[fidx] = true;
-            }
-        }
-
-        // the vertex has now no living adjacent triangles anymore
-        piNumTriPtr[ivdx] = 0;
-
-        // get next fanning vertex
-        ivdx = -1;
-        int max_priority = -1;
-        for (unsigned int* piCur = piCandidates;piCur != piCurCandidate;++piCur)    {
-            const unsigned int dp = *piCur;
-
-            // must have live triangles
-            if (piNumTriPtr[dp] > 0)    {
-                int priority = 0;
-
-                // will the vertex be in cache, even after fanning occurs?
-                unsigned int tmp;
-                if ((tmp = iStampCnt-piCachingStamps[dp]) + 2*piNumTriPtr[dp] <= mConfigCacheDepth) {
-                    priority = tmp;
-                }
-
-                // keep best candidate
-                if (priority > max_priority) {
-                    max_priority = priority;
-                    ivdx = dp;
-                }
-            }
-        }
-        // did we reach a dead end?
-        if (-1 == ivdx) {
-            // need to get a non-local vertex for which we have a good chance that it is still
-            // in the cache ...
-            while (!sDeadEndVStack.empty()) {
-                unsigned int iCachedIdx = sDeadEndVStack.top();
-                sDeadEndVStack.pop();
-                if (piNumTriPtr[ iCachedIdx ] > 0)  {
-                    ivdx = iCachedIdx;
-                    break;
-                }
-            }
-
-            if (-1 == ivdx) {
-                // well, there isn't such a vertex. Simply get the next vertex in input order and
-                // hope it is not too bad ...
-                while (ics < (int)pMesh->mNumVertices)  {
-                    ++ics;
-                    if (piNumTriPtr[ics] > 0)   {
-                        ivdx = ics;
-                        break;
-                    }
-                }
-            }
-        }
-    }
-    ai_real fACMR2 = 0.0f;
-    if (!DefaultLogger::isNullLogger()) {
-        fACMR2 = (float)iCacheMisses / pMesh->mNumFaces;
-
-        // very intense verbose logging ... prepare for much text if there are many meshes
-        if ( DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) {
-            ASSIMP_LOG_DEBUG_F("Mesh %u | ACMR in: ", meshNum, " out: ", fACMR, " | ~", fACMR2, ((fACMR - fACMR2) / fACMR) * 100.f);
-        }
-
-        fACMR2 *= pMesh->mNumFaces;
-    }
-    // sort the output index buffer back to the input array
-    piCSIter = piIBOutput;
-    for (aiFace* pcFace = pMesh->mFaces; pcFace != pcEnd;++pcFace)  {
-        unsigned nind = pcFace->mNumIndices;
-        unsigned * ind = pcFace->mIndices;
-        if (nind > 0) ind[0] = *piCSIter++;
-        if (nind > 1) ind[1] = *piCSIter++;
-        if (nind > 2) ind[2] = *piCSIter++;
-    }
-
-    // delete temporary storage
-    delete[] piCachingStamps;
-    delete[] piIBOutput;
-    delete[] piCandidates;
-
-    return fACMR2;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h b/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h
deleted file mode 100644
index de25ecd9fb..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ImproveCacheLocality.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to reorder faces for
- better cache locality*/
-#ifndef AI_IMPROVECACHELOCALITY_H_INC
-#define AI_IMPROVECACHELOCALITY_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/types.h>
-
-struct aiMesh;
-
-namespace Assimp
-{
-
-// ---------------------------------------------------------------------------
-/** The ImproveCacheLocalityProcess reorders all faces for improved vertex
- *  cache locality. It tries to arrange all faces to fans and to render
- *  faces which share vertices directly one after the other.
- *
- *  @note This step expects triagulated input data.
- */
-class ImproveCacheLocalityProcess : public BaseProcess
-{
-public:
-
-    ImproveCacheLocalityProcess();
-    ~ImproveCacheLocalityProcess();
-
-public:
-
-    // -------------------------------------------------------------------
-    // Check whether the pp step is active
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    // Executes the pp step on a given scene
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    // Configures the pp step
-    void SetupProperties(const Importer* pImp);
-
-protected:
-    // -------------------------------------------------------------------
-    /** Executes the postprocessing step on the given mesh
-     * @param pMesh The mesh to process.
-     * @param meshNum Index of the mesh to process
-     */
-    ai_real ProcessMesh( aiMesh* pMesh, unsigned int meshNum);
-
-private:
-    //! Configuration parameter: specifies the size of the cache to
-    //! optimize the vertex data for.
-    unsigned int mConfigCacheDepth;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_IMPROVECACHELOCALITY_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp b/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp
deleted file mode 100644
index f121fc60d3..0000000000
--- a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.cpp
+++ /dev/null
@@ -1,438 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the post processing step to join identical vertices
- * for all imported meshes
- */
-
-
-#ifndef ASSIMP_BUILD_NO_JOINVERTICES_PROCESS
-
-#include "JoinVerticesProcess.h"
-#include "ProcessHelper.h"
-#include <assimp/Vertex.h>
-#include <assimp/TinyFormatter.h>
-#include <stdio.h>
-#include <unordered_set>
-
-using namespace Assimp;
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-JoinVerticesProcess::JoinVerticesProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-JoinVerticesProcess::~JoinVerticesProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool JoinVerticesProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_JoinIdenticalVertices) != 0;
-}
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void JoinVerticesProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("JoinVerticesProcess begin");
-
-    // get the total number of vertices BEFORE the step is executed
-    int iNumOldVertices = 0;
-    if (!DefaultLogger::isNullLogger()) {
-        for( unsigned int a = 0; a < pScene->mNumMeshes; a++)   {
-            iNumOldVertices +=  pScene->mMeshes[a]->mNumVertices;
-        }
-    }
-
-    // execute the step
-    int iNumVertices = 0;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-        iNumVertices += ProcessMesh( pScene->mMeshes[a],a);
-
-    // if logging is active, print detailed statistics
-    if (!DefaultLogger::isNullLogger()) {
-        if (iNumOldVertices == iNumVertices) {
-            ASSIMP_LOG_DEBUG("JoinVerticesProcess finished ");
-        } else {
-            ASSIMP_LOG_INFO_F("JoinVerticesProcess finished | Verts in: ", iNumOldVertices,
-                " out: ", iNumVertices, " | ~",
-                ((iNumOldVertices - iNumVertices) / (float)iNumOldVertices) * 100.f );
-        }
-    }
-
-    pScene->mFlags |= AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
-}
-
-namespace {
-
-bool areVerticesEqual(const Vertex &lhs, const Vertex &rhs, bool complex)
-{
-    // A little helper to find locally close vertices faster.
-    // Try to reuse the lookup table from the last step.
-    const static float epsilon = 1e-5f;
-    // Squared because we check against squared length of the vector difference
-    static const float squareEpsilon = epsilon * epsilon;
-
-    // Square compare is useful for animeshes vertices compare
-    if ((lhs.position - rhs.position).SquareLength() > squareEpsilon) {
-        return false;
-    }
-
-    // We just test the other attributes even if they're not present in the mesh.
-    // In this case they're initialized to 0 so the comparison succeeds.
-    // By this method the non-present attributes are effectively ignored in the comparison.
-    if ((lhs.normal - rhs.normal).SquareLength() > squareEpsilon) {
-        return false;
-    }
-
-    if ((lhs.texcoords[0] - rhs.texcoords[0]).SquareLength() > squareEpsilon) {
-        return false;
-    }
-
-    if ((lhs.tangent - rhs.tangent).SquareLength() > squareEpsilon) {
-        return false;
-    }
-
-    if ((lhs.bitangent - rhs.bitangent).SquareLength() > squareEpsilon) {
-        return false;
-    }
-
-    // Usually we won't have vertex colors or multiple UVs, so we can skip from here
-    // Actually this increases runtime performance slightly, at least if branch
-    // prediction is on our side.
-    if (complex) {
-        for (int i = 0; i < 8; i++) {
-            if (i > 0 && (lhs.texcoords[i] - rhs.texcoords[i]).SquareLength() > squareEpsilon) {
-                return false;
-            }
-            if (GetColorDifference(lhs.colors[i], rhs.colors[i]) > squareEpsilon) {
-                return false;
-            }
-        }
-    }
-    return true;
-}
-
-template<class XMesh>
-void updateXMeshVertices(XMesh *pMesh, std::vector<Vertex> &uniqueVertices) {
-    // replace vertex data with the unique data sets
-    pMesh->mNumVertices = (unsigned int)uniqueVertices.size();
-
-    // ----------------------------------------------------------------------------
-    // NOTE - we're *not* calling Vertex::SortBack() because it would check for
-    // presence of every single vertex component once PER VERTEX. And our CPU
-    // dislikes branches, even if they're easily predictable.
-    // ----------------------------------------------------------------------------
-
-    // Position, if present (check made for aiAnimMesh)
-    if (pMesh->mVertices)
-    {
-        delete [] pMesh->mVertices;
-        pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
-        for (unsigned int a = 0; a < pMesh->mNumVertices; a++) {
-            pMesh->mVertices[a] = uniqueVertices[a].position;
-        }
-    }
-
-    // Normals, if present
-    if (pMesh->mNormals)
-    {
-        delete [] pMesh->mNormals;
-        pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-        for( unsigned int a = 0; a < pMesh->mNumVertices; a++) {
-            pMesh->mNormals[a] = uniqueVertices[a].normal;
-        }
-    }
-    // Tangents, if present
-    if (pMesh->mTangents)
-    {
-        delete [] pMesh->mTangents;
-        pMesh->mTangents = new aiVector3D[pMesh->mNumVertices];
-        for (unsigned int a = 0; a < pMesh->mNumVertices; a++) {
-            pMesh->mTangents[a] = uniqueVertices[a].tangent;
-        }
-    }
-    // Bitangents as well
-    if (pMesh->mBitangents)
-    {
-        delete [] pMesh->mBitangents;
-        pMesh->mBitangents = new aiVector3D[pMesh->mNumVertices];
-        for (unsigned int a = 0; a < pMesh->mNumVertices; a++) {
-            pMesh->mBitangents[a] = uniqueVertices[a].bitangent;
-        }
-    }
-    // Vertex colors
-    for (unsigned int a = 0; pMesh->HasVertexColors(a); a++)
-    {
-        delete [] pMesh->mColors[a];
-        pMesh->mColors[a] = new aiColor4D[pMesh->mNumVertices];
-        for( unsigned int b = 0; b < pMesh->mNumVertices; b++) {
-            pMesh->mColors[a][b] = uniqueVertices[b].colors[a];
-        }
-    }
-    // Texture coords
-    for (unsigned int a = 0; pMesh->HasTextureCoords(a); a++)
-    {
-        delete [] pMesh->mTextureCoords[a];
-        pMesh->mTextureCoords[a] = new aiVector3D[pMesh->mNumVertices];
-        for (unsigned int b = 0; b < pMesh->mNumVertices; b++) {
-            pMesh->mTextureCoords[a][b] = uniqueVertices[b].texcoords[a];
-        }
-    }
-}
-} // namespace
-
-// ------------------------------------------------------------------------------------------------
-// Unites identical vertices in the given mesh
-int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
-{
-    static_assert( AI_MAX_NUMBER_OF_COLOR_SETS    == 8, "AI_MAX_NUMBER_OF_COLOR_SETS    == 8");
-	static_assert( AI_MAX_NUMBER_OF_TEXTURECOORDS == 8, "AI_MAX_NUMBER_OF_TEXTURECOORDS == 8");
-
-    // Return early if we don't have any positions
-    if (!pMesh->HasPositions() || !pMesh->HasFaces()) {
-        return 0;
-    }
-
-    // We should care only about used vertices, not all of them
-    // (this can happen due to original file vertices buffer being used by
-    // multiple meshes)
-    std::unordered_set<unsigned int> usedVertexIndices;
-    usedVertexIndices.reserve(pMesh->mNumVertices);
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        aiFace& face = pMesh->mFaces[a];
-        for( unsigned int b = 0; b < face.mNumIndices; b++) {
-            usedVertexIndices.insert(face.mIndices[b]);
-        }
-    }
-
-    // We'll never have more vertices afterwards.
-    std::vector<Vertex> uniqueVertices;
-    uniqueVertices.reserve( pMesh->mNumVertices);
-
-    // For each vertex the index of the vertex it was replaced by.
-    // Since the maximal number of vertices is 2^31-1, the most significand bit can be used to mark
-    //  whether a new vertex was created for the index (true) or if it was replaced by an existing
-    //  unique vertex (false). This saves an additional std::vector<bool> and greatly enhances
-    //  branching performance.
-    static_assert(AI_MAX_VERTICES == 0x7fffffff, "AI_MAX_VERTICES == 0x7fffffff");
-    std::vector<unsigned int> replaceIndex( pMesh->mNumVertices, 0xffffffff);
-
-    // float posEpsilonSqr;
-    SpatialSort* vertexFinder = NULL;
-    SpatialSort _vertexFinder;
-
-    typedef std::pair<SpatialSort,float> SpatPair;
-    if (shared) {
-        std::vector<SpatPair >* avf;
-        shared->GetProperty(AI_SPP_SPATIAL_SORT,avf);
-        if (avf)    {
-            SpatPair& blubb = (*avf)[meshIndex];
-            vertexFinder  = &blubb.first;
-            // posEpsilonSqr = blubb.second;
-        }
-    }
-    if (!vertexFinder)  {
-        // bad, need to compute it.
-        _vertexFinder.Fill(pMesh->mVertices, pMesh->mNumVertices, sizeof( aiVector3D));
-        vertexFinder = &_vertexFinder;
-        // posEpsilonSqr = ComputePositionEpsilon(pMesh);
-    }
-
-    // Again, better waste some bytes than a realloc ...
-    std::vector<unsigned int> verticesFound;
-    verticesFound.reserve(10);
-
-    // Run an optimized code path if we don't have multiple UVs or vertex colors.
-    // This should yield false in more than 99% of all imports ...
-    const bool complex = ( pMesh->GetNumColorChannels() > 0 || pMesh->GetNumUVChannels() > 1);
-    const bool hasAnimMeshes = pMesh->mNumAnimMeshes > 0;
-
-    // We'll never have more vertices afterwards.
-    std::vector<std::vector<Vertex>> uniqueAnimatedVertices;
-    if (hasAnimMeshes) {
-        uniqueAnimatedVertices.resize(pMesh->mNumAnimMeshes);
-        for (unsigned int animMeshIndex = 0; animMeshIndex < pMesh->mNumAnimMeshes; animMeshIndex++) {
-            uniqueAnimatedVertices[animMeshIndex].reserve(pMesh->mNumVertices);
-        }
-    }
-
-    // Now check each vertex if it brings something new to the table
-    for( unsigned int a = 0; a < pMesh->mNumVertices; a++)  {
-        if (usedVertexIndices.find(a) == usedVertexIndices.end()) {
-            continue;
-        }
-
-        // collect the vertex data
-        Vertex v(pMesh,a);
-
-        // collect all vertices that are close enough to the given position
-        vertexFinder->FindIdenticalPositions( v.position, verticesFound);
-        unsigned int matchIndex = 0xffffffff;
-
-        // check all unique vertices close to the position if this vertex is already present among them
-        for( unsigned int b = 0; b < verticesFound.size(); b++) {
-            const unsigned int vidx = verticesFound[b];
-            const unsigned int uidx = replaceIndex[ vidx];
-            if( uidx & 0x80000000)
-                continue;
-
-            const Vertex& uv = uniqueVertices[ uidx];
-
-            if (!areVerticesEqual(v, uv, complex)) {
-                continue;
-            }
-
-            if (hasAnimMeshes) {
-                // If given vertex is animated, then it has to be preserver 1 to 1 (base mesh and animated mesh require same topology)
-                // NOTE: not doing this totaly breaks anim meshes as they don't have their own faces (they use pMesh->mFaces)
-                bool breaksAnimMesh = false;
-                for (unsigned int animMeshIndex = 0; animMeshIndex < pMesh->mNumAnimMeshes; animMeshIndex++) {
-                    const Vertex& animatedUV = uniqueAnimatedVertices[animMeshIndex][ uidx];
-                    Vertex aniMeshVertex(pMesh->mAnimMeshes[animMeshIndex], a);
-                    if (!areVerticesEqual(aniMeshVertex, animatedUV, complex)) {
-                        breaksAnimMesh = true;
-                        break;
-                    }
-                }
-                if (breaksAnimMesh) {
-                    continue;
-                }
-            }
-
-            // we're still here -> this vertex perfectly matches our given vertex
-            matchIndex = uidx;
-            break;
-        }
-
-        // found a replacement vertex among the uniques?
-        if( matchIndex != 0xffffffff)
-        {
-            // store where to found the matching unique vertex
-            replaceIndex[a] = matchIndex | 0x80000000;
-        }
-        else
-        {
-            // no unique vertex matches it up to now -> so add it
-            replaceIndex[a] = (unsigned int)uniqueVertices.size();
-            uniqueVertices.push_back( v);
-            if (hasAnimMeshes) {
-                for (unsigned int animMeshIndex = 0; animMeshIndex < pMesh->mNumAnimMeshes; animMeshIndex++) {
-                    Vertex aniMeshVertex(pMesh->mAnimMeshes[animMeshIndex], a);
-                    uniqueAnimatedVertices[animMeshIndex].push_back(aniMeshVertex);
-                }
-            }
-        }
-    }
-
-    if (!DefaultLogger::isNullLogger() && DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE)    {
-        ASSIMP_LOG_DEBUG_F(
-            "Mesh ",meshIndex,
-            " (",
-            (pMesh->mName.length ? pMesh->mName.data : "unnamed"),
-            ") | Verts in: ",pMesh->mNumVertices,
-            " out: ",
-            uniqueVertices.size(),
-            " | ~",
-            ((pMesh->mNumVertices - uniqueVertices.size()) / (float)pMesh->mNumVertices) * 100.f,
-            "%"
-        );
-    }
-
-    updateXMeshVertices(pMesh, uniqueVertices);
-    if (hasAnimMeshes) {
-        for (unsigned int animMeshIndex = 0; animMeshIndex < pMesh->mNumAnimMeshes; animMeshIndex++) {
-            updateXMeshVertices(pMesh->mAnimMeshes[animMeshIndex], uniqueAnimatedVertices[animMeshIndex]);
-        }
-    }
-
-    // adjust the indices in all faces
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++)
-    {
-        aiFace& face = pMesh->mFaces[a];
-        for( unsigned int b = 0; b < face.mNumIndices; b++) {
-            face.mIndices[b] = replaceIndex[face.mIndices[b]] & ~0x80000000;
-        }
-    }
-
-    // adjust bone vertex weights.
-    for( int a = 0; a < (int)pMesh->mNumBones; a++) {
-        aiBone* bone = pMesh->mBones[a];
-        std::vector<aiVertexWeight> newWeights;
-        newWeights.reserve( bone->mNumWeights);
-
-        if ( NULL != bone->mWeights ) {
-            for ( unsigned int b = 0; b < bone->mNumWeights; b++ ) {
-                const aiVertexWeight& ow = bone->mWeights[ b ];
-                // if the vertex is a unique one, translate it
-                if ( !( replaceIndex[ ow.mVertexId ] & 0x80000000 ) ) {
-                    aiVertexWeight nw;
-                    nw.mVertexId = replaceIndex[ ow.mVertexId ];
-                    nw.mWeight = ow.mWeight;
-                    newWeights.push_back( nw );
-                }
-            }
-        } else {
-            ASSIMP_LOG_ERROR( "X-Export: aiBone shall contain weights, but pointer to them is NULL." );
-        }
-
-        if (newWeights.size() > 0) {
-            // kill the old and replace them with the translated weights
-            delete [] bone->mWeights;
-            bone->mNumWeights = (unsigned int)newWeights.size();
-
-            bone->mWeights = new aiVertexWeight[bone->mNumWeights];
-            memcpy( bone->mWeights, &newWeights[0], bone->mNumWeights * sizeof( aiVertexWeight));
-        }
-    }
-    return pMesh->mNumVertices;
-}
-
-#endif // !! ASSIMP_BUILD_NO_JOINVERTICES_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h b/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h
deleted file mode 100644
index e017ae62db..0000000000
--- a/thirdparty/assimp/code/PostProcessing/JoinVerticesProcess.h
+++ /dev/null
@@ -1,95 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to join identical vertices
-    on all imported meshes.*/
-#ifndef AI_JOINVERTICESPROCESS_H_INC
-#define AI_JOINVERTICESPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/types.h>
-
-struct aiMesh;
-
-namespace Assimp
-{
-
-// ---------------------------------------------------------------------------
-/** The JoinVerticesProcess unites identical vertices in all imported meshes.
- * By default the importer returns meshes where each face addressed its own
- * set of vertices even if that means that identical vertices are stored multiple
- * times. The JoinVerticesProcess finds these identical vertices and
- * erases all but one of the copies. This usually reduces the number of vertices
- * in a mesh by a serious amount and is the standard form to render a mesh.
- */
-class ASSIMP_API JoinVerticesProcess : public BaseProcess {
-public:
-    JoinVerticesProcess();
-    ~JoinVerticesProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-     * @param pFlags The processing flags the importer was called with. A bitwise
-     *   combination of #aiPostProcessSteps.
-     * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    /** Unites identical vertices in the given mesh.
-     * @param pMesh The mesh to process.
-     * @param meshIndex Index of the mesh to process
-     */
-    int ProcessMesh( aiMesh* pMesh, unsigned int meshIndex);
-};
-
-} // end of namespace Assimp
-
-#endif // AI_CALCTANGENTSPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp b/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
deleted file mode 100644
index d560f19287..0000000000
--- a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.cpp
+++ /dev/null
@@ -1,201 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** Implementation of the LimitBoneWeightsProcess post processing step */
-
-
-#include "LimitBoneWeightsProcess.h"
-#include <assimp/StringUtils.h>
-#include <assimp/postprocess.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-#include <stdio.h>
-
-using namespace Assimp;
-
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-LimitBoneWeightsProcess::LimitBoneWeightsProcess()
-{
-    mMaxWeights = AI_LMW_MAX_WEIGHTS;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-LimitBoneWeightsProcess::~LimitBoneWeightsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool LimitBoneWeightsProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_LimitBoneWeights) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void LimitBoneWeightsProcess::Execute( aiScene* pScene) {
-    ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess begin");
-    for (unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
-        ProcessMesh(pScene->mMeshes[a]);
-    }
-
-    ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess end");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void LimitBoneWeightsProcess::SetupProperties(const Importer* pImp)
-{
-    // get the current value of the property
-    this->mMaxWeights = pImp->GetPropertyInteger(AI_CONFIG_PP_LBW_MAX_WEIGHTS,AI_LMW_MAX_WEIGHTS);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Unites identical vertices in the given mesh
-void LimitBoneWeightsProcess::ProcessMesh( aiMesh* pMesh)
-{
-    if( !pMesh->HasBones())
-        return;
-
-    // collect all bone weights per vertex
-    typedef std::vector< std::vector< Weight > > WeightsPerVertex;
-    WeightsPerVertex vertexWeights( pMesh->mNumVertices);
-
-    // collect all weights per vertex
-    for( unsigned int a = 0; a < pMesh->mNumBones; a++)
-    {
-        const aiBone* bone = pMesh->mBones[a];
-        for( unsigned int b = 0; b < bone->mNumWeights; b++)
-        {
-            const aiVertexWeight& w = bone->mWeights[b];
-            vertexWeights[w.mVertexId].push_back( Weight( a, w.mWeight));
-        }
-    }
-
-    unsigned int removed = 0, old_bones = pMesh->mNumBones;
-
-    // now cut the weight count if it exceeds the maximum
-    bool bChanged = false;
-    for( WeightsPerVertex::iterator vit = vertexWeights.begin(); vit != vertexWeights.end(); ++vit)
-    {
-        if( vit->size() <= mMaxWeights)
-            continue;
-
-        bChanged = true;
-
-        // more than the defined maximum -> first sort by weight in descending order. That's
-        // why we defined the < operator in such a weird way.
-        std::sort( vit->begin(), vit->end());
-
-        // now kill everything beyond the maximum count
-        unsigned int m = static_cast<unsigned int>(vit->size());
-        vit->erase( vit->begin() + mMaxWeights, vit->end());
-        removed += static_cast<unsigned int>(m-vit->size());
-
-        // and renormalize the weights
-        float sum = 0.0f;
-        for( std::vector<Weight>::const_iterator it = vit->begin(); it != vit->end(); ++it ) {
-            sum += it->mWeight;
-        }
-        if( 0.0f != sum ) {
-            const float invSum = 1.0f / sum;
-            for( std::vector<Weight>::iterator it = vit->begin(); it != vit->end(); ++it ) {
-                it->mWeight *= invSum;
-            }
-        }
-    }
-
-    if (bChanged)   {
-        // rebuild the vertex weight array for all bones
-        typedef std::vector< std::vector< aiVertexWeight > > WeightsPerBone;
-        WeightsPerBone boneWeights( pMesh->mNumBones);
-        for( unsigned int a = 0; a < vertexWeights.size(); a++)
-        {
-            const std::vector<Weight>& vw = vertexWeights[a];
-            for( std::vector<Weight>::const_iterator it = vw.begin(); it != vw.end(); ++it)
-                boneWeights[it->mBone].push_back( aiVertexWeight( a, it->mWeight));
-        }
-
-        // and finally copy the vertex weight list over to the mesh's bones
-        std::vector<bool> abNoNeed(pMesh->mNumBones,false);
-        bChanged = false;
-
-        for( unsigned int a = 0; a < pMesh->mNumBones; a++)
-        {
-            const std::vector<aiVertexWeight>& bw = boneWeights[a];
-            aiBone* bone = pMesh->mBones[a];
-
-            if ( bw.empty() )
-            {
-                abNoNeed[a] = bChanged = true;
-                continue;
-            }
-
-            // copy the weight list. should always be less weights than before, so we don't need a new allocation
-            ai_assert( bw.size() <= bone->mNumWeights);
-            bone->mNumWeights = static_cast<unsigned int>( bw.size() );
-            ::memcpy( bone->mWeights, &bw[0], bw.size() * sizeof( aiVertexWeight));
-        }
-
-        if (bChanged)   {
-            // the number of new bones is smaller than before, so we can reuse the old array
-            aiBone** ppcCur = pMesh->mBones;aiBone** ppcSrc = ppcCur;
-
-            for (std::vector<bool>::const_iterator iter  = abNoNeed.begin();iter != abNoNeed.end()  ;++iter)    {
-                if (*iter)  {
-                    delete *ppcSrc;
-                    --pMesh->mNumBones;
-                }
-                else *ppcCur++ = *ppcSrc;
-                ++ppcSrc;
-            }
-        }
-
-        if (!DefaultLogger::isNullLogger()) {
-            ASSIMP_LOG_INFO_F("Removed ", removed, " weights. Input bones: ", old_bones, ". Output bones: ", pMesh->mNumBones );
-        }
-    }
-}
diff --git a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h b/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
deleted file mode 100644
index 73c2a68d53..0000000000
--- a/thirdparty/assimp/code/PostProcessing/LimitBoneWeightsProcess.h
+++ /dev/null
@@ -1,138 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** Defines a post processing step to limit the number of bones affecting a single vertex. */
-#ifndef AI_LIMITBONEWEIGHTSPROCESS_H_INC
-#define AI_LIMITBONEWEIGHTSPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-// Forward declarations
-struct aiMesh;
-
-class LimitBoneWeightsTest;
-
-namespace Assimp {
-
-// NOTE: If you change these limits, don't forget to change the
-// corresponding values in all Assimp ports
-
-// **********************************************************
-// Java: ConfigProperty.java,
-//  ConfigProperty.DEFAULT_BONE_WEIGHT_LIMIT
-// **********************************************************
-
-#if (!defined AI_LMW_MAX_WEIGHTS)
-#   define AI_LMW_MAX_WEIGHTS   0x4
-#endif // !! AI_LMW_MAX_WEIGHTS
-
-// ---------------------------------------------------------------------------
-/** This post processing step limits the number of bones affecting a vertex
-* to a certain maximum value. If a vertex is affected by more than that number
-* of bones, the bone weight with the least influence on this vertex are removed.
-* The other weights on this bone are then renormalized to assure the sum weight
-* to be 1.
-*/
-class ASSIMP_API LimitBoneWeightsProcess : public BaseProcess {
-public:
-    LimitBoneWeightsProcess();
-    ~LimitBoneWeightsProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag.
-    * @param pFlags The processing flags the importer was called with.
-    *   A bitwise combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields,
-    *   false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    /** Limits the bone weight count for all vertices in the given mesh.
-    * @param pMesh The mesh to process.
-    */
-    void ProcessMesh( aiMesh* pMesh);
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    /** Describes a bone weight on a vertex */
-    struct Weight {
-        unsigned int mBone; ///< Index of the bone
-        float mWeight;      ///< Weight of that bone on this vertex
-        Weight() AI_NO_EXCEPT
-        : mBone(0)
-        , mWeight(0.0f) {
-            // empty
-        }
-
-        Weight( unsigned int pBone, float pWeight)
-        : mBone(pBone)
-        , mWeight(pWeight) {
-            // empty
-        }
-
-        /** Comparison operator to sort bone weights by descending weight */
-        bool operator < (const Weight& pWeight) const {
-            return mWeight > pWeight.mWeight;
-        }
-    };
-
-    /** Maximum number of bones influencing any single vertex. */
-    unsigned int mMaxWeights;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_LIMITBONEWEIGHTSPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp b/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp
deleted file mode 100644
index 41f50a5ba5..0000000000
--- a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.cpp
+++ /dev/null
@@ -1,255 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-/** @file Implementation of the post processing step "MakeVerboseFormat"
-*/
-
-
-#include "MakeVerboseFormat.h"
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-MakeVerboseFormatProcess::MakeVerboseFormatProcess()
-{
-    // nothing to do here
-}
-// ------------------------------------------------------------------------------------------------
-MakeVerboseFormatProcess::~MakeVerboseFormatProcess()
-{
-    // nothing to do here
-}
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void MakeVerboseFormatProcess::Execute( aiScene* pScene)
-{
-    ai_assert(NULL != pScene);
-    ASSIMP_LOG_DEBUG("MakeVerboseFormatProcess begin");
-
-    bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-    {
-        if( MakeVerboseFormat( pScene->mMeshes[a]))
-            bHas = true;
-    }
-    if (bHas) {
-        ASSIMP_LOG_INFO("MakeVerboseFormatProcess finished. There was much work to do ...");
-    } else {
-        ASSIMP_LOG_DEBUG("MakeVerboseFormatProcess. There was nothing to do.");
-    }
-
-    pScene->mFlags &= ~AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)
-{
-    ai_assert(NULL != pcMesh);
-
-    unsigned int iOldNumVertices = pcMesh->mNumVertices;
-    const unsigned int iNumVerts = pcMesh->mNumFaces*3;
-
-    aiVector3D* pvPositions = new aiVector3D[ iNumVerts ];
-
-    aiVector3D* pvNormals = NULL;
-    if (pcMesh->HasNormals())
-    {
-        pvNormals = new aiVector3D[iNumVerts];
-    }
-    aiVector3D* pvTangents = NULL, *pvBitangents = NULL;
-    if (pcMesh->HasTangentsAndBitangents())
-    {
-        pvTangents = new aiVector3D[iNumVerts];
-        pvBitangents = new aiVector3D[iNumVerts];
-    }
-
-    aiVector3D* apvTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS] = {0};
-    aiColor4D* apvColorSets[AI_MAX_NUMBER_OF_COLOR_SETS] = {0};
-
-    unsigned int p = 0;
-    while (pcMesh->HasTextureCoords(p))
-        apvTextureCoords[p++] = new aiVector3D[iNumVerts];
-
-    p = 0;
-    while (pcMesh->HasVertexColors(p))
-        apvColorSets[p++] = new aiColor4D[iNumVerts];
-
-    // allocate enough memory to hold output bones and vertex weights ...
-    std::vector<aiVertexWeight>* newWeights = new std::vector<aiVertexWeight>[pcMesh->mNumBones];
-    for (unsigned int i = 0;i < pcMesh->mNumBones;++i) {
-        newWeights[i].reserve(pcMesh->mBones[i]->mNumWeights*3);
-    }
-
-    // iterate through all faces and build a clean list
-    unsigned int iIndex = 0;
-    for (unsigned int a = 0; a< pcMesh->mNumFaces;++a)
-    {
-        aiFace* pcFace = &pcMesh->mFaces[a];
-        for (unsigned int q = 0; q < pcFace->mNumIndices;++q,++iIndex)
-        {
-            // need to build a clean list of bones, too
-            for (unsigned int i = 0;i < pcMesh->mNumBones;++i)
-            {
-                for (unsigned int a = 0;  a < pcMesh->mBones[i]->mNumWeights;a++)
-                {
-                    const aiVertexWeight& w = pcMesh->mBones[i]->mWeights[a];
-                    if(pcFace->mIndices[q] == w.mVertexId)
-                    {
-                        aiVertexWeight wNew;
-                        wNew.mVertexId = iIndex;
-                        wNew.mWeight = w.mWeight;
-                        newWeights[i].push_back(wNew);
-                    }
-                }
-            }
-
-            pvPositions[iIndex] = pcMesh->mVertices[pcFace->mIndices[q]];
-
-            if (pcMesh->HasNormals())
-            {
-                pvNormals[iIndex] = pcMesh->mNormals[pcFace->mIndices[q]];
-            }
-            if (pcMesh->HasTangentsAndBitangents())
-            {
-                pvTangents[iIndex] = pcMesh->mTangents[pcFace->mIndices[q]];
-                pvBitangents[iIndex] = pcMesh->mBitangents[pcFace->mIndices[q]];
-            }
-
-            unsigned int p = 0;
-            while (pcMesh->HasTextureCoords(p))
-            {
-                apvTextureCoords[p][iIndex] = pcMesh->mTextureCoords[p][pcFace->mIndices[q]];
-                ++p;
-            }
-            p = 0;
-            while (pcMesh->HasVertexColors(p))
-            {
-                apvColorSets[p][iIndex] = pcMesh->mColors[p][pcFace->mIndices[q]];
-                ++p;
-            }
-            pcFace->mIndices[q] = iIndex;
-        }
-    }
-
-
-
-    // build output vertex weights
-    for (unsigned int i = 0;i < pcMesh->mNumBones;++i)
-    {
-        delete [] pcMesh->mBones[i]->mWeights;
-        if (!newWeights[i].empty()) {
-            pcMesh->mBones[i]->mWeights = new aiVertexWeight[newWeights[i].size()];
-            aiVertexWeight *weightToCopy = &( newWeights[i][0] );
-            memcpy(pcMesh->mBones[i]->mWeights, weightToCopy,
-                sizeof(aiVertexWeight) * newWeights[i].size());
-        } else {
-            pcMesh->mBones[i]->mWeights = NULL;
-        }
-    }
-    delete[] newWeights;
-
-    // delete the old members
-    delete[] pcMesh->mVertices;
-    pcMesh->mVertices = pvPositions;
-
-    p = 0;
-    while (pcMesh->HasTextureCoords(p))
-    {
-        delete[] pcMesh->mTextureCoords[p];
-        pcMesh->mTextureCoords[p] = apvTextureCoords[p];
-        ++p;
-    }
-    p = 0;
-    while (pcMesh->HasVertexColors(p))
-    {
-        delete[] pcMesh->mColors[p];
-        pcMesh->mColors[p] = apvColorSets[p];
-        ++p;
-    }
-    pcMesh->mNumVertices = iNumVerts;
-
-    if (pcMesh->HasNormals())
-    {
-        delete[] pcMesh->mNormals;
-        pcMesh->mNormals = pvNormals;
-    }
-    if (pcMesh->HasTangentsAndBitangents())
-    {
-        delete[] pcMesh->mTangents;
-        pcMesh->mTangents = pvTangents;
-        delete[] pcMesh->mBitangents;
-        pcMesh->mBitangents = pvBitangents;
-    }
-    return (pcMesh->mNumVertices != iOldNumVertices);
-}
-
-
-// ------------------------------------------------------------------------------------------------
-bool IsMeshInVerboseFormat(const aiMesh* mesh) {
-    // avoid slow vector<bool> specialization
-    std::vector<unsigned int> seen(mesh->mNumVertices,0);
-    for(unsigned int i = 0; i < mesh->mNumFaces; ++i) {
-        const aiFace& f = mesh->mFaces[i];
-        for(unsigned int j = 0; j < f.mNumIndices; ++j) {
-            if(++seen[f.mIndices[j]] == 2) {
-                // found a duplicate index
-                return false;
-            }
-        }
-    }
-
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-bool MakeVerboseFormatProcess::IsVerboseFormat(const aiScene* pScene) {
-    for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        if(!IsMeshInVerboseFormat(pScene->mMeshes[i])) {
-            return false;
-        }
-    }
-
-    return true;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h b/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h
deleted file mode 100644
index 8565d5933a..0000000000
--- a/thirdparty/assimp/code/PostProcessing/MakeVerboseFormat.h
+++ /dev/null
@@ -1,113 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to bring a given scene
- into the verbose format that is expected by most postprocess steps.
- This is the inverse of the "JoinIdenticalVertices" step. */
-#ifndef AI_MAKEVERBOSEFORMAT_H_INC
-#define AI_MAKEVERBOSEFORMAT_H_INC
-
-#include "Common/BaseProcess.h"
-
-struct aiMesh;
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** MakeVerboseFormatProcess: Class to convert an asset to the verbose
- *  format which is expected by most postprocess steps.
- *
- * This is the inverse of what the "JoinIdenticalVertices" step is doing.
- * This step has no official flag (since it wouldn't make sense to run it
- * during import). It is intended for applications intending to modify the
- * returned aiScene. After this step has been executed, they can execute
- * other postprocess steps on the data. The code might also be useful to
- * quickly adapt code that doesn't result in a verbose representation of
- * the scene data.
- * The step has been added because it was required by the viewer, however
- * it has been moved to the main library since others might find it
- * useful, too. */
-class ASSIMP_API_WINONLY MakeVerboseFormatProcess : public BaseProcess
-{
-public:
-
-
-    MakeVerboseFormatProcess();
-    ~MakeVerboseFormatProcess();
-
-public:
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-    * @param pFlags The processing flags the importer was called with. A bitwise
-    *   combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields, false if not */
-    bool IsActive( unsigned int /*pFlags*/ ) const
-    {
-        // NOTE: There is no direct flag that corresponds to
-        // this postprocess step.
-        return false;
-    }
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at. */
-    void Execute( aiScene* pScene);
-
-public:
-
-    // -------------------------------------------------------------------
-    /** Checks whether the scene is already in verbose format.
-    * @param pScene The data to check. 
-    * @return true if the scene is already in verbose format. */
-    static bool IsVerboseFormat(const aiScene* pScene);
-
-private:
-
-    //! Apply the postprocess step to a given submesh
-    bool MakeVerboseFormat (aiMesh* pcMesh);
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_KILLNORMALPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp b/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp
deleted file mode 100644
index 5db51f58b6..0000000000
--- a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.cpp
+++ /dev/null
@@ -1,351 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  OptimizeGraph.cpp
- *  @brief Implementation of the aiProcess_OptimizGraph step
- */
-
-
-#ifndef ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
-
-#include "OptimizeGraph.h"
-#include "ProcessHelper.h"
-#include <assimp/SceneCombiner.h>
-#include <assimp/Exceptional.h>
-#include <stdio.h>
-
-using namespace Assimp;
-
-#define AI_RESERVED_NODE_NAME "$Reserved_And_Evil"
-
-/* AI_OG_USE_HASHING enables the use of hashing to speed-up std::set lookups.
- * 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)
-#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)
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-OptimizeGraphProcess::OptimizeGraphProcess()
-: mScene()
-, nodes_in()
-, nodes_out()
-, count_merged() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-OptimizeGraphProcess::~OptimizeGraphProcess() {
-    // 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));
-}
-
-// ------------------------------------------------------------------------------------------------
-// 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);
-}
-
-// ------------------------------------------------------------------------------------------------
-// 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 = 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;
-
-    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) {
-#ifdef AI_OG_USE_HASHING
-        locked.insert(SuperFastHash((*it).c_str()));
-#else
-        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 = 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]);
-}
-
-#endif // !! ASSIMP_BUILD_NO_OPTIMIZEGRAPH_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h b/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h
deleted file mode 100644
index 82cc5db3fe..0000000000
--- a/thirdparty/assimp/code/PostProcessing/OptimizeGraph.h
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  OptimizeGraph.h
- *  @brief Declares a post processing step to optimize the scenegraph
- */
-#ifndef AI_OPTIMIZEGRAPHPROCESS_H_INC
-#define AI_OPTIMIZEGRAPHPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-#include "PostProcessing/ProcessHelper.h"
-
-#include <assimp/types.h>
-
-#include <set>
-
-// Forward declarations
-struct aiMesh;
-
-class OptimizeGraphProcessTest;
-
-namespace Assimp    {
-
-// -----------------------------------------------------------------------------
-/** @brief Postprocessing step to optimize the scenegraph
- *
- *  The implementation tries to merge nodes, even if they use different
- *  transformations. Animations are preserved.
- *
- *  @see aiProcess_OptimizeGraph for a detailed description of the
- *  algorithm being applied.
- */
-class OptimizeGraphProcess : public BaseProcess {
-public:
-    OptimizeGraphProcess();
-    ~OptimizeGraphProcess();
-
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    /** @brief Add a list of node names to be locked and not modified.
-     *  @param in List of nodes. See #AI_CONFIG_PP_OG_EXCLUDE_LIST for
-     *    format explanations.
-     */
-    inline void AddLockedNodeList(std::string& in) {
-        ConvertListToStrings (in,locked_nodes);
-    }
-
-    // -------------------------------------------------------------------
-    /** @brief Add another node to be locked and not modified.
-     *  @param name Name to be locked
-     */
-    inline void AddLockedNode(std::string& name) {
-        locked_nodes.push_back(name);
-    }
-
-    // -------------------------------------------------------------------
-    /** @brief Remove a node from the list of locked nodes.
-     *  @param name Name to be unlocked
-     */
-    inline void RemoveLockedNode(std::string& name) {
-        locked_nodes.remove(name);
-    }
-
-protected:
-    void CollectNewChildren(aiNode* nd, std::list<aiNode*>& nodes);
-    void FindInstancedMeshes (aiNode* pNode);
-
-private:
-#ifdef AI_OG_USE_HASHING
-    typedef std::set<unsigned int> LockedSetType;
-#else
-    typedef std::set<std::string> LockedSetType;
-#endif
-
-    //! Scene we're working with
-    aiScene* mScene;
-
-    //! List of locked names. Stored is the hash of the name
-    LockedSetType locked;
-
-    //! List of nodes to be locked in addition to those with animations, lights or cameras assigned.
-    std::list<std::string> locked_nodes;
-
-    //! Node counters for logging purposes
-    unsigned int nodes_in,nodes_out, count_merged;
-
-    //! Reference counters for meshes
-    std::vector<unsigned int> meshes;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_OPTIMIZEGRAPHPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp b/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp
deleted file mode 100644
index 3f6765f6ca..0000000000
--- a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.cpp
+++ /dev/null
@@ -1,256 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  OptimizeMeshes.cpp
- *  @brief Implementation of the aiProcess_OptimizeMeshes step
- */
-
-
-#ifndef ASSIMP_BUILD_NO_OPTIMIZEMESHES_PROCESS
-
-
-#include "OptimizeMeshes.h"
-#include "ProcessHelper.h"
-#include <assimp/SceneCombiner.h>
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-
-static const unsigned int NotSet   = 0xffffffff;
-static const unsigned int DeadBeef = 0xdeadbeef;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-OptimizeMeshesProcess::OptimizeMeshesProcess()
-    : mScene()
-    , pts(false)
-    , max_verts( NotSet )
-    , max_faces( NotSet ) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-OptimizeMeshesProcess::~OptimizeMeshesProcess() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool OptimizeMeshesProcess::IsActive( unsigned int pFlags) const
-{
-    // Our behaviour needs to be different if the SortByPType or SplitLargeMeshes
-    // steps are active. Thus we need to query their flags here and store the
-    // information, although we're breaking const-correctness.
-    // That's a serious design flaw, consider redesign.
-    if( 0 != (pFlags & aiProcess_OptimizeMeshes) ) {
-        pts = (0 != (pFlags & aiProcess_SortByPType));
-        max_verts = ( 0 != ( pFlags & aiProcess_SplitLargeMeshes ) ) ? DeadBeef : max_verts;
-        return true;
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup properties for the post-processing step
-void OptimizeMeshesProcess::SetupProperties(const Importer* pImp)
-{
-    if( max_verts == DeadBeef /* magic hack */ ) {
-        max_faces = pImp->GetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT,AI_SLM_DEFAULT_MAX_TRIANGLES);
-        max_verts = pImp->GetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT,AI_SLM_DEFAULT_MAX_VERTICES);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Execute step
-void OptimizeMeshesProcess::Execute( aiScene* pScene)
-{
-    const unsigned int num_old = pScene->mNumMeshes;
-    if (num_old <= 1) {
-        ASSIMP_LOG_DEBUG("Skipping OptimizeMeshesProcess");
-        return;
-    }
-
-    ASSIMP_LOG_DEBUG("OptimizeMeshesProcess begin");
-    mScene = pScene;
-
-    // need to clear persistent members from previous runs
-    merge_list.resize( 0 );
-    output.resize( 0 );
-
-    // ensure we have the right sizes
-    merge_list.reserve(pScene->mNumMeshes);
-    output.reserve(pScene->mNumMeshes);
-
-    // Prepare lookup tables
-    meshes.resize(pScene->mNumMeshes);
-    FindInstancedMeshes(pScene->mRootNode);
-    if( max_verts == DeadBeef ) /* undo the magic hack */
-        max_verts = NotSet;
-
-    // ... instanced meshes are immediately processed and added to the output list
-    for (unsigned int i = 0, n = 0; i < pScene->mNumMeshes;++i) {
-        meshes[i].vertex_format = GetMeshVFormatUnique(pScene->mMeshes[i]);
-
-        if (meshes[i].instance_cnt > 1 && meshes[i].output_id == NotSet ) {
-            meshes[i].output_id = n++;
-            output.push_back(mScene->mMeshes[i]);
-        }
-    }
-
-    // and process all nodes in the scenegraph recursively
-    ProcessNode(pScene->mRootNode);
-    if (!output.size()) {
-        throw DeadlyImportError("OptimizeMeshes: No meshes remaining; there's definitely something wrong");
-    }
-
-    meshes.resize( 0 );
-    ai_assert(output.size() <= num_old);
-
-    mScene->mNumMeshes = static_cast<unsigned int>(output.size());
-    std::copy(output.begin(),output.end(),mScene->mMeshes);
-
-    if (output.size() != num_old) {
-        ASSIMP_LOG_DEBUG_F("OptimizeMeshesProcess finished. Input meshes: ", num_old, ", Output meshes: ", pScene->mNumMeshes);
-    } else {
-        ASSIMP_LOG_DEBUG( "OptimizeMeshesProcess finished" );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Process meshes for a single node
-void OptimizeMeshesProcess::ProcessNode( aiNode* pNode)
-{
-    for (unsigned int i = 0; i < pNode->mNumMeshes;++i) {
-        unsigned int& im = pNode->mMeshes[i];
-
-        if (meshes[im].instance_cnt > 1) {
-            im = meshes[im].output_id;
-        }
-        else  {
-            merge_list.resize( 0 );
-            unsigned int verts = 0, faces = 0;
-
-            // Find meshes to merge with us
-            for (unsigned int a = i+1; a < pNode->mNumMeshes;++a) {
-                unsigned int am = pNode->mMeshes[a];
-                if (meshes[am].instance_cnt == 1 && CanJoin(im,am,verts,faces)) {
-
-                    merge_list.push_back(mScene->mMeshes[am]);
-                    verts += mScene->mMeshes[am]->mNumVertices;
-                    faces += mScene->mMeshes[am]->mNumFaces;
-
-                    pNode->mMeshes[a] = pNode->mMeshes[pNode->mNumMeshes - 1];
-                    --pNode->mNumMeshes;
-                    --a;
-                }
-            }
-
-            // and merge all meshes which we found, replace the old ones
-            if (!merge_list.empty()) {
-                merge_list.push_back(mScene->mMeshes[im]);
-
-                aiMesh* out;
-                SceneCombiner::MergeMeshes(&out,0,merge_list.begin(),merge_list.end());
-                output.push_back(out);
-            } else {
-                output.push_back(mScene->mMeshes[im]);
-            }
-            im = static_cast<unsigned int>(output.size()-1);
-        }
-    }
-
-
-    for( unsigned int i = 0; i < pNode->mNumChildren; ++i ) {
-        ProcessNode( pNode->mChildren[ i ] );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Check whether two meshes can be joined
-bool OptimizeMeshesProcess::CanJoin ( unsigned int a, unsigned int b, unsigned int verts, unsigned int faces )
-{
-    if (meshes[a].vertex_format != meshes[b].vertex_format)
-        return false;
-
-    aiMesh* ma = mScene->mMeshes[a], *mb = mScene->mMeshes[b];
-
-    if ((NotSet != max_verts && verts+mb->mNumVertices > max_verts) ||
-        (NotSet != max_faces && faces+mb->mNumFaces    > max_faces)) {
-        return false;
-    }
-
-    // Never merge unskinned meshes with skinned meshes
-    if (ma->mMaterialIndex != mb->mMaterialIndex || ma->HasBones() != mb->HasBones())
-        return false;
-
-    // Never merge meshes with different kinds of primitives if SortByPType did already
-    // do its work. We would destroy everything again ...
-    if (pts && ma->mPrimitiveTypes != mb->mPrimitiveTypes)
-        return false;
-
-    // If both meshes are skinned, check whether we have many bones defined in both meshes.
-    // If yes, we can join them.
-    if (ma->HasBones()) {
-        // TODO
-        return false;
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build a LUT of all instanced meshes
-void OptimizeMeshesProcess::FindInstancedMeshes (aiNode* pNode)
-{
-    for( unsigned int i = 0; i < pNode->mNumMeshes; ++i ) {
-        ++meshes[ pNode->mMeshes[ i ] ].instance_cnt;
-    }
-
-    for( unsigned int i = 0; i < pNode->mNumChildren; ++i ) {
-        FindInstancedMeshes( pNode->mChildren[ i ] );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-
-#endif // !! ASSIMP_BUILD_NO_OPTIMIZEMESHES_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h b/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h
deleted file mode 100644
index dec4ab52de..0000000000
--- a/thirdparty/assimp/code/PostProcessing/OptimizeMeshes.h
+++ /dev/null
@@ -1,186 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file  OptimizeMeshes.h
- *  @brief Declares a post processing step to join meshes, if possible
- */
-#ifndef AI_OPTIMIZEMESHESPROCESS_H_INC
-#define AI_OPTIMIZEMESHESPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/types.h>
-
-#include <vector>
-
-struct aiMesh;
-struct aiNode;
-class OptimizeMeshesProcessTest;
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** @brief Postprocessing step to optimize mesh usage
- *
- *  The implementation looks for meshes that could be joined and joins them.
- *  Usually this will reduce the number of drawcalls.
- *
- *  @note Instanced meshes are currently not processed.
- */
-class OptimizeMeshesProcess : public BaseProcess {
-public:
-    /// @brief  The class constructor.
-    OptimizeMeshesProcess();
-
-    /// @brief  The class destructor.
-    ~OptimizeMeshesProcess();
-
-    /** @brief Internal utility to store additional mesh info
-     */
-    struct MeshInfo {
-        MeshInfo() AI_NO_EXCEPT
-        : instance_cnt(0)
-        , vertex_format(0)
-        , output_id(0xffffffff) {
-            // empty
-        }
-
-        //! Number of times this mesh is referenced
-        unsigned int instance_cnt;
-
-        //! Vertex format id
-        unsigned int vertex_format;
-
-        //! Output ID
-        unsigned int output_id;
-    };
-
-public:
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
-
-
-    // -------------------------------------------------------------------
-    /** @brief Specify whether you want meshes with different
-     *   primitive types to be merged as well.
-     *
-     *  IsActive() sets this property automatically to true if the
-     *  aiProcess_SortByPType flag is found.
-     */
-    void EnablePrimitiveTypeSorting(bool enable) {
-        pts = enable;
-    }
-
-    // Getter
-    bool IsPrimitiveTypeSortingEnabled () const {
-        return pts;
-    }
-
-
-    // -------------------------------------------------------------------
-    /** @brief Specify a maximum size of a single output mesh.
-     *
-     *  If a single input mesh already exceeds this limit, it won't
-     *  be split.
-     *  @param verts Maximum number of vertices per mesh
-     *  @param faces Maximum number of faces per mesh
-     */
-    void SetPreferredMeshSizeLimit (unsigned int verts, unsigned int faces)
-    {
-        max_verts = verts;
-        max_faces = faces;
-    }
-
-
-protected:
-
-    // -------------------------------------------------------------------
-    /** @brief Do the actual optimization on all meshes of this node
-     *  @param pNode Node we're working with
-     */
-    void ProcessNode( aiNode* pNode);
-
-    // -------------------------------------------------------------------
-    /** @brief Returns true if b can be joined with a
-     *
-     *  @param verts Number of output verts up to now
-     *  @param faces Number of output faces up to now
-     */
-    bool CanJoin ( unsigned int a, unsigned int b,
-        unsigned int verts, unsigned int faces );
-
-    // -------------------------------------------------------------------
-    /** @brief Find instanced meshes, for the moment we're excluding
-     *   them from all optimizations
-     */
-    void FindInstancedMeshes (aiNode* pNode);
-
-private:
-
-    //! Scene we're working with
-    aiScene* mScene;
-
-    //! Per mesh info
-    std::vector<MeshInfo> meshes;
-
-    //! Output meshes
-    std::vector<aiMesh*> output;
-
-    //! @see EnablePrimitiveTypeSorting
-    mutable bool pts;
-
-    //! @see SetPreferredMeshSizeLimit
-    mutable unsigned int max_verts,max_faces;
-
-    //! Temporary storage
-    std::vector<aiMesh*> merge_list;
-};
-
-} // end of namespace Assimp
-
-#endif // AI_CALCTANGENTSPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp b/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp
deleted file mode 100644
index 52001a0578..0000000000
--- a/thirdparty/assimp/code/PostProcessing/PretransformVertices.cpp
+++ /dev/null
@@ -1,728 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file PretransformVertices.cpp
- *  @brief Implementation of the "PretransformVertices" post processing step
-*/
-
-
-#include "PretransformVertices.h"
-#include "ProcessHelper.h"
-#include <assimp/SceneCombiner.h>
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-
-// some array offsets
-#define AI_PTVS_VERTEX 0x0
-#define AI_PTVS_FACE 0x1
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-PretransformVertices::PretransformVertices()
-: configKeepHierarchy (false)
-, configNormalize(false)
-, configTransform(false)
-, configTransformation()
-, mConfigPointCloud( false ) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-PretransformVertices::~PretransformVertices() {
-    // 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;
-}
-
-// ------------------------------------------------------------------------------------------------
-// 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));
-
-    configTransformation = pImp->GetPropertyMatrix(AI_CONFIG_PP_PTV_ROOT_TRANSFORMATION, aiMatrix4x4());
-
-    mConfigPointCloud = pImp->GetPropertyBool(AI_CONFIG_EXPORT_POINT_CLOUDS);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Count the number of nodes
-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 )
-{
-    // 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( 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( 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( 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]);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Apply the node transformation to a mesh
-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)
-{
-    // 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)
-{
-    nd->mTransformation = aiMatrix4x4();
-
-    // call children
-    for (unsigned int i = 0; i < nd->mNumChildren;++i)
-        MakeIdentityTransform(nd->mChildren[i]);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Build reference counters for all meshes
-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, ")");
-    }
-}
diff --git a/thirdparty/assimp/code/PostProcessing/PretransformVertices.h b/thirdparty/assimp/code/PostProcessing/PretransformVertices.h
deleted file mode 100644
index b2982951e0..0000000000
--- a/thirdparty/assimp/code/PostProcessing/PretransformVertices.h
+++ /dev/null
@@ -1,166 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file PretransformVertices.h
- *  @brief Defines a post processing step to pretransform all
- *    vertices in the scenegraph
- */
-#ifndef AI_PRETRANSFORMVERTICES_H_INC
-#define AI_PRETRANSFORMVERTICES_H_INC
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-
-#include <list>
-#include <vector>
-
-// Forward declarations
-struct aiNode;
-
-class PretransformVerticesTest;
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** The PretransformVertices pre-transforms all vertices in the node tree
- *  and removes the whole graph. The output is a list of meshes, one for
- *  each material.
-*/
-class ASSIMP_API PretransformVertices : public BaseProcess {
-public:
-    PretransformVertices ();
-    ~PretransformVertices ();
-
-    // -------------------------------------------------------------------
-    // Check whether step is active
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    // Execute step on a given scene
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    // Setup import settings
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    /** @brief Toggle the 'keep hierarchy' option
-     *  @param keep    true for keep configuration.
-     */
-    void KeepHierarchy(bool keep) {
-        configKeepHierarchy = keep;
-    }
-
-    // -------------------------------------------------------------------
-    /** @brief Check whether 'keep hierarchy' is currently enabled.
-     *  @return ...
-     */
-    bool IsHierarchyKept() const {
-        return configKeepHierarchy;
-    }
-
-private:
-    // -------------------------------------------------------------------
-    // 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
-
-#endif // !!AI_GENFACENORMALPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp b/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp
deleted file mode 100644
index 59869fdff7..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ProcessHelper.cpp
+++ /dev/null
@@ -1,443 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/// @file ProcessHelper.cpp
-/** Implement shared utility functions for postprocessing steps */
-
-
-#include "ProcessHelper.h"
-
-
-#include <limits>
-
-namespace Assimp {
-
-// -------------------------------------------------------------------------------
-void ConvertListToStrings(const std::string& in, std::list<std::string>& out)
-{
-    const char* s = in.c_str();
-    while (*s) {
-        SkipSpacesAndLineEnd(&s);
-        if (*s == '\'') {
-            const char* base = ++s;
-            while (*s != '\'') {
-                ++s;
-                if (*s == '\0') {
-                    ASSIMP_LOG_ERROR("ConvertListToString: String list is ill-formatted");
-                    return;
-                }
-            }
-            out.push_back(std::string(base,(size_t)(s-base)));
-            ++s;
-        }
-        else {
-            out.push_back(GetNextToken(s));
-        }
-    }
-}
-
-// -------------------------------------------------------------------------------
-void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max,
-    const aiMatrix4x4& m)
-{
-    min = aiVector3D ( ai_real( 10e10 ), ai_real( 10e10 ), ai_real( 10e10 ) );
-    max = aiVector3D ( ai_real( -10e10 ), ai_real( -10e10 ), ai_real( -10e10 ) );
-    for (unsigned int i = 0;i < mesh->mNumVertices;++i)
-    {
-        const aiVector3D v = m * mesh->mVertices[i];
-        min = std::min(v,min);
-        max = std::max(v,max);
-    }
-}
-
-// -------------------------------------------------------------------------------
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max)
-{
-    ArrayBounds(mesh->mVertices,mesh->mNumVertices, min,max);
-    out = min + (max-min)*(ai_real)0.5;
-}
-
-// -------------------------------------------------------------------------------
-void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector3D& max) {
-    if ( NULL == scene ) {
-        return;
-    }
-
-    if ( 0 == scene->mNumMeshes ) {
-        return;
-    }
-    FindMeshCenter(scene->mMeshes[0], out, min, max);
-    for (unsigned int i = 1; i < scene->mNumMeshes; ++i) {
-        aiVector3D tout, tmin, tmax;
-        FindMeshCenter(scene->mMeshes[i], tout, tmin, tmax);
-        if (min[0] > tmin[0]) min[0] = tmin[0];
-        if (min[1] > tmin[1]) min[1] = tmin[1];
-        if (min[2] > tmin[2]) min[2] = tmin[2];
-        if (max[0] < tmax[0]) max[0] = tmax[0];
-        if (max[1] < tmax[1]) max[1] = tmax[1];
-        if (max[2] < tmax[2]) max[2] = tmax[2];
-    }
-    out = min + (max-min)*(ai_real)0.5;
-}
-
-
-// -------------------------------------------------------------------------------
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out, aiVector3D& min,
-    aiVector3D& max, const aiMatrix4x4& m)
-{
-    FindAABBTransformed(mesh,min,max,m);
-    out = min + (max-min)*(ai_real)0.5;
-}
-
-// -------------------------------------------------------------------------------
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out)
-{
-    aiVector3D min,max;
-    FindMeshCenter(mesh,out,min,max);
-}
-
-// -------------------------------------------------------------------------------
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out,
-    const aiMatrix4x4& m)
-{
-    aiVector3D min,max;
-    FindMeshCenterTransformed(mesh,out,min,max,m);
-}
-
-// -------------------------------------------------------------------------------
-ai_real ComputePositionEpsilon(const aiMesh* pMesh)
-{
-    const ai_real epsilon = ai_real( 1e-4 );
-
-    // calculate the position bounds so we have a reliable epsilon to check position differences against
-    aiVector3D minVec, maxVec;
-    ArrayBounds(pMesh->mVertices,pMesh->mNumVertices,minVec,maxVec);
-    return (maxVec - minVec).Length() * epsilon;
-}
-
-// -------------------------------------------------------------------------------
-ai_real ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num)
-{
-    ai_assert( NULL != pMeshes );
-
-    const ai_real epsilon = ai_real( 1e-4 );
-
-    // calculate the position bounds so we have a reliable epsilon to check position differences against
-    aiVector3D minVec, maxVec, mi, ma;
-    MinMaxChooser<aiVector3D>()(minVec,maxVec);
-
-    for (size_t a = 0; a < num; ++a) {
-        const aiMesh* pMesh = pMeshes[a];
-        ArrayBounds(pMesh->mVertices,pMesh->mNumVertices,mi,ma);
-
-        minVec = std::min(minVec,mi);
-        maxVec = std::max(maxVec,ma);
-    }
-    return (maxVec - minVec).Length() * epsilon;
-}
-
-
-// -------------------------------------------------------------------------------
-unsigned int GetMeshVFormatUnique(const aiMesh* pcMesh)
-{
-    ai_assert(NULL != pcMesh);
-
-    // FIX: the hash may never be 0. Otherwise a comparison against
-    // nullptr could be successful
-    unsigned int iRet = 1;
-
-    // normals
-    if (pcMesh->HasNormals())iRet |= 0x2;
-    // tangents and bitangents
-    if (pcMesh->HasTangentsAndBitangents())iRet |= 0x4;
-
-#ifdef BOOST_STATIC_ASSERT
-    BOOST_STATIC_ASSERT(8 >= AI_MAX_NUMBER_OF_COLOR_SETS);
-    BOOST_STATIC_ASSERT(8 >= AI_MAX_NUMBER_OF_TEXTURECOORDS);
-#endif
-
-    // texture coordinates
-    unsigned int p = 0;
-    while (pcMesh->HasTextureCoords(p))
-    {
-        iRet |= (0x100 << p);
-        if (3 == pcMesh->mNumUVComponents[p])
-            iRet |= (0x10000 << p);
-
-        ++p;
-    }
-    // vertex colors
-    p = 0;
-    while (pcMesh->HasVertexColors(p))iRet |= (0x1000000 << p++);
-    return iRet;
-}
-
-// -------------------------------------------------------------------------------
-VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh)
-{
-    if (!pMesh || !pMesh->mNumVertices || !pMesh->mNumBones) {
-        return NULL;
-    }
-
-    VertexWeightTable* avPerVertexWeights = new VertexWeightTable[pMesh->mNumVertices];
-    for (unsigned int i = 0; i < pMesh->mNumBones;++i)  {
-
-        aiBone* bone = pMesh->mBones[i];
-        for (unsigned int a = 0; a < bone->mNumWeights;++a) {
-            const aiVertexWeight& weight = bone->mWeights[a];
-            avPerVertexWeights[weight.mVertexId].push_back( std::pair<unsigned int,float>(i,weight.mWeight) );
-        }
-    }
-    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)
-{
-    switch (in)
-    {
-    case aiTextureMapping_UV:
-        return "UV";
-    case aiTextureMapping_BOX:
-        return "Box";
-    case aiTextureMapping_SPHERE:
-        return "Sphere";
-    case aiTextureMapping_CYLINDER:
-        return "Cylinder";
-    case aiTextureMapping_PLANE:
-        return "Plane";
-    case aiTextureMapping_OTHER:
-        return "Other";
-    default:
-        break;
-    }
-
-    ai_assert(false);
-    return  "BUG";
-}
-
-
-// -------------------------------------------------------------------------------
-aiMesh* MakeSubmesh(const aiMesh *pMesh, const std::vector<unsigned int> &subMeshFaces, unsigned int subFlags)
-{
-    aiMesh *oMesh = new aiMesh();
-    std::vector<unsigned int> vMap(pMesh->mNumVertices,UINT_MAX);
-
-    size_t numSubVerts = 0;
-    size_t numSubFaces = subMeshFaces.size();
-
-    for(unsigned int i=0;i<numSubFaces;i++) {
-        const aiFace &f = pMesh->mFaces[subMeshFaces[i]];
-
-        for(unsigned int j=0;j<f.mNumIndices;j++)   {
-            if(vMap[f.mIndices[j]]==UINT_MAX)   {
-                vMap[f.mIndices[j]] = static_cast<unsigned int>(numSubVerts++);
-            }
-        }
-    }
-
-    oMesh->mName = pMesh->mName;
-
-    oMesh->mMaterialIndex = pMesh->mMaterialIndex;
-    oMesh->mPrimitiveTypes = pMesh->mPrimitiveTypes;
-
-    // create all the arrays for this mesh if the old mesh contained them
-
-    oMesh->mNumFaces = static_cast<unsigned int>(subMeshFaces.size());
-    oMesh->mNumVertices = static_cast<unsigned int>(numSubVerts);
-    oMesh->mVertices = new aiVector3D[numSubVerts];
-    if( pMesh->HasNormals() ) {
-        oMesh->mNormals = new aiVector3D[numSubVerts];
-    }
-
-    if( pMesh->HasTangentsAndBitangents() ) {
-        oMesh->mTangents = new aiVector3D[numSubVerts];
-        oMesh->mBitangents = new aiVector3D[numSubVerts];
-    }
-
-    for( size_t a = 0;  pMesh->HasTextureCoords(static_cast<unsigned int>(a)) ; ++a ) {
-        oMesh->mTextureCoords[a] = new aiVector3D[numSubVerts];
-        oMesh->mNumUVComponents[a] = pMesh->mNumUVComponents[a];
-    }
-
-    for( size_t a = 0; pMesh->HasVertexColors( static_cast<unsigned int>(a)); ++a )    {
-        oMesh->mColors[a] = new aiColor4D[numSubVerts];
-    }
-
-    // and copy over the data, generating faces with linear indices along the way
-    oMesh->mFaces = new aiFace[numSubFaces];
-
-    for(unsigned int a = 0; a < numSubFaces; ++a )  {
-
-        const aiFace& srcFace = pMesh->mFaces[subMeshFaces[a]];
-        aiFace& dstFace = oMesh->mFaces[a];
-        dstFace.mNumIndices = srcFace.mNumIndices;
-        dstFace.mIndices = new unsigned int[dstFace.mNumIndices];
-
-        // accumulate linearly all the vertices of the source face
-        for( size_t b = 0; b < dstFace.mNumIndices; ++b )   {
-            dstFace.mIndices[b] = vMap[srcFace.mIndices[b]];
-        }
-    }
-
-    for(unsigned int srcIndex = 0; srcIndex < pMesh->mNumVertices; ++srcIndex ) {
-        unsigned int nvi = vMap[srcIndex];
-        if(nvi==UINT_MAX) {
-            continue;
-        }
-
-        oMesh->mVertices[nvi] = pMesh->mVertices[srcIndex];
-        if( pMesh->HasNormals() ) {
-            oMesh->mNormals[nvi] = pMesh->mNormals[srcIndex];
-        }
-
-        if( pMesh->HasTangentsAndBitangents() ) {
-            oMesh->mTangents[nvi] = pMesh->mTangents[srcIndex];
-            oMesh->mBitangents[nvi] = pMesh->mBitangents[srcIndex];
-        }
-        for( size_t c = 0, cc = pMesh->GetNumUVChannels(); c < cc; ++c )    {
-                oMesh->mTextureCoords[c][nvi] = pMesh->mTextureCoords[c][srcIndex];
-        }
-        for( size_t c = 0, cc = pMesh->GetNumColorChannels(); c < cc; ++c ) {
-            oMesh->mColors[c][nvi] = pMesh->mColors[c][srcIndex];
-        }
-    }
-
-    if(~subFlags&AI_SUBMESH_FLAGS_SANS_BONES)   {
-        std::vector<unsigned int> subBones(pMesh->mNumBones,0);
-
-        for(unsigned int a=0;a<pMesh->mNumBones;++a)    {
-            const aiBone* bone = pMesh->mBones[a];
-
-            for(unsigned int b=0;b<bone->mNumWeights;b++)   {
-                unsigned int v = vMap[bone->mWeights[b].mVertexId];
-
-                if(v!=UINT_MAX) {
-                    subBones[a]++;
-                }
-            }
-        }
-
-        for(unsigned int a=0;a<pMesh->mNumBones;++a)    {
-            if(subBones[a]>0) {
-                oMesh->mNumBones++;
-            }
-        }
-
-        if(oMesh->mNumBones) {
-            oMesh->mBones = new aiBone*[oMesh->mNumBones]();
-            unsigned int nbParanoia = oMesh->mNumBones;
-
-            oMesh->mNumBones = 0; //rewind
-
-            for(unsigned int a=0;a<pMesh->mNumBones;++a)    {
-                if(subBones[a]==0) {
-                    continue;
-                }
-                aiBone *newBone = new aiBone;
-                oMesh->mBones[oMesh->mNumBones++] = newBone;
-
-                const aiBone* bone = pMesh->mBones[a];
-
-                newBone->mName = bone->mName;
-                newBone->mOffsetMatrix = bone->mOffsetMatrix;
-                newBone->mWeights = new aiVertexWeight[subBones[a]];
-
-                for(unsigned int b=0;b<bone->mNumWeights;b++)   {
-                    const unsigned int v = vMap[bone->mWeights[b].mVertexId];
-
-                    if(v!=UINT_MAX) {
-                        aiVertexWeight w(v,bone->mWeights[b].mWeight);
-                        newBone->mWeights[newBone->mNumWeights++] = w;
-                    }
-                }
-            }
-
-            ai_assert(nbParanoia==oMesh->mNumBones);
-            (void)nbParanoia; // remove compiler warning on release build
-        }
-    }
-
-    return oMesh;
-}
-
-} // namespace Assimp
diff --git a/thirdparty/assimp/code/PostProcessing/ProcessHelper.h b/thirdparty/assimp/code/PostProcessing/ProcessHelper.h
deleted file mode 100644
index 0afcc41420..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ProcessHelper.h
+++ /dev/null
@@ -1,386 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef AI_PROCESS_HELPER_H_INCLUDED
-#define AI_PROCESS_HELPER_H_INCLUDED
-
-#include <assimp/postprocess.h>
-#include <assimp/anim.h>
-#include <assimp/mesh.h>
-#include <assimp/material.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-
-#include <assimp/SpatialSort.h>
-#include "Common/BaseProcess.h"
-#include <assimp/ParsingUtils.h>
-
-#include <list>
-
-// -------------------------------------------------------------------------------
-// Some extensions to std namespace. Mainly std::min and std::max for all
-// flat data types in the aiScene. They're used to quickly determine the
-// min/max bounds of data arrays.
-#ifdef __cplusplus
-namespace std {
-
-    // std::min for aiVector3D
-    template <typename TReal>
-    inline ::aiVector3t<TReal> min (const ::aiVector3t<TReal>& a, const ::aiVector3t<TReal>& b) {
-        return ::aiVector3t<TReal> (min(a.x,b.x),min(a.y,b.y),min(a.z,b.z));
-    }
-
-    // std::max for aiVector3t<TReal>
-    template <typename TReal>
-    inline ::aiVector3t<TReal> max (const ::aiVector3t<TReal>& a, const ::aiVector3t<TReal>& b) {
-        return ::aiVector3t<TReal> (max(a.x,b.x),max(a.y,b.y),max(a.z,b.z));
-    }
-
-    // std::min for aiVector2t<TReal>
-    template <typename TReal>
-    inline ::aiVector2t<TReal> min (const ::aiVector2t<TReal>& a, const ::aiVector2t<TReal>& b) {
-        return ::aiVector2t<TReal> (min(a.x,b.x),min(a.y,b.y));
-    }
-
-    // std::max for aiVector2t<TReal>
-    template <typename TReal>
-    inline ::aiVector2t<TReal> max (const ::aiVector2t<TReal>& a, const ::aiVector2t<TReal>& b) {
-        return ::aiVector2t<TReal> (max(a.x,b.x),max(a.y,b.y));
-    }
-
-    // std::min for aiColor4D
-    template <typename TReal>
-    inline ::aiColor4t<TReal> min (const ::aiColor4t<TReal>& a, const ::aiColor4t<TReal>& b)    {
-        return ::aiColor4t<TReal> (min(a.r,b.r),min(a.g,b.g),min(a.b,b.b),min(a.a,b.a));
-    }
-
-    // std::max for aiColor4D
-    template <typename TReal>
-    inline ::aiColor4t<TReal> max (const ::aiColor4t<TReal>& a, const ::aiColor4t<TReal>& b)    {
-        return ::aiColor4t<TReal> (max(a.r,b.r),max(a.g,b.g),max(a.b,b.b),max(a.a,b.a));
-    }
-
-
-    // std::min for aiQuaterniont<TReal>
-    template <typename TReal>
-    inline ::aiQuaterniont<TReal> min (const ::aiQuaterniont<TReal>& a, const ::aiQuaterniont<TReal>& b)    {
-        return ::aiQuaterniont<TReal> (min(a.w,b.w),min(a.x,b.x),min(a.y,b.y),min(a.z,b.z));
-    }
-
-    // std::max for aiQuaterniont<TReal>
-    template <typename TReal>
-    inline ::aiQuaterniont<TReal> max (const ::aiQuaterniont<TReal>& a, const ::aiQuaterniont<TReal>& b)    {
-        return ::aiQuaterniont<TReal> (max(a.w,b.w),max(a.x,b.x),max(a.y,b.y),max(a.z,b.z));
-    }
-
-
-
-    // std::min for aiVectorKey
-    inline ::aiVectorKey min (const ::aiVectorKey& a, const ::aiVectorKey& b)   {
-        return ::aiVectorKey (min(a.mTime,b.mTime),min(a.mValue,b.mValue));
-    }
-
-    // std::max for aiVectorKey
-    inline ::aiVectorKey max (const ::aiVectorKey& a, const ::aiVectorKey& b)   {
-        return ::aiVectorKey (max(a.mTime,b.mTime),max(a.mValue,b.mValue));
-    }
-
-    // std::min for aiQuatKey
-    inline ::aiQuatKey min (const ::aiQuatKey& a, const ::aiQuatKey& b) {
-        return ::aiQuatKey (min(a.mTime,b.mTime),min(a.mValue,b.mValue));
-    }
-
-    // std::max for aiQuatKey
-    inline ::aiQuatKey max (const ::aiQuatKey& a, const ::aiQuatKey& b) {
-        return ::aiQuatKey (max(a.mTime,b.mTime),max(a.mValue,b.mValue));
-    }
-
-    // std::min for aiVertexWeight
-    inline ::aiVertexWeight min (const ::aiVertexWeight& a, const ::aiVertexWeight& b)  {
-        return ::aiVertexWeight (min(a.mVertexId,b.mVertexId),min(a.mWeight,b.mWeight));
-    }
-
-    // std::max for aiVertexWeight
-    inline ::aiVertexWeight max (const ::aiVertexWeight& a, const ::aiVertexWeight& b)  {
-        return ::aiVertexWeight (max(a.mVertexId,b.mVertexId),max(a.mWeight,b.mWeight));
-    }
-
-} // end namespace std
-#endif // !! C++
-
-namespace Assimp {
-
-// -------------------------------------------------------------------------------
-// Start points for ArrayBounds<T> for all supported Ts
-template <typename T>
-struct MinMaxChooser;
-
-template <> struct MinMaxChooser<float> {
-    void operator ()(float& min,float& max) {
-        max = -1e10f;
-        min =  1e10f;
-}};
-template <> struct MinMaxChooser<double> {
-    void operator ()(double& min,double& max) {
-        max = -1e10;
-        min =  1e10;
-}};
-template <> struct MinMaxChooser<unsigned int> {
-    void operator ()(unsigned int& min,unsigned int& max) {
-        max = 0;
-        min = (1u<<(sizeof(unsigned int)*8-1));
-}};
-
-template <typename T> struct MinMaxChooser< aiVector3t<T> > {
-    void operator ()(aiVector3t<T>& min,aiVector3t<T>& max) {
-        max = aiVector3t<T>(-1e10f,-1e10f,-1e10f);
-        min = aiVector3t<T>( 1e10f, 1e10f, 1e10f);
-}};
-template <typename T> struct MinMaxChooser< aiVector2t<T> > {
-    void operator ()(aiVector2t<T>& min,aiVector2t<T>& max) {
-        max = aiVector2t<T>(-1e10f,-1e10f);
-        min = aiVector2t<T>( 1e10f, 1e10f);
-    }};
-template <typename T> struct MinMaxChooser< aiColor4t<T> > {
-    void operator ()(aiColor4t<T>& min,aiColor4t<T>& max) {
-        max = aiColor4t<T>(-1e10f,-1e10f,-1e10f,-1e10f);
-        min = aiColor4t<T>( 1e10f, 1e10f, 1e10f, 1e10f);
-}};
-
-template <typename T> struct MinMaxChooser< aiQuaterniont<T> > {
-    void operator ()(aiQuaterniont<T>& min,aiQuaterniont<T>& max) {
-        max = aiQuaterniont<T>(-1e10f,-1e10f,-1e10f,-1e10f);
-        min = aiQuaterniont<T>( 1e10f, 1e10f, 1e10f, 1e10f);
-}};
-
-template <> struct MinMaxChooser<aiVectorKey> {
-    void operator ()(aiVectorKey& min,aiVectorKey& max) {
-        MinMaxChooser<double>()(min.mTime,max.mTime);
-        MinMaxChooser<aiVector3D>()(min.mValue,max.mValue);
-}};
-template <> struct MinMaxChooser<aiQuatKey> {
-    void operator ()(aiQuatKey& min,aiQuatKey& max) {
-        MinMaxChooser<double>()(min.mTime,max.mTime);
-        MinMaxChooser<aiQuaternion>()(min.mValue,max.mValue);
-}};
-
-template <> struct MinMaxChooser<aiVertexWeight> {
-    void operator ()(aiVertexWeight& min,aiVertexWeight& max) {
-        MinMaxChooser<unsigned int>()(min.mVertexId,max.mVertexId);
-        MinMaxChooser<float>()(min.mWeight,max.mWeight);
-}};
-
-// -------------------------------------------------------------------------------
-/** @brief Find the min/max values of an array of Ts
- *  @param in Input array
- *  @param size Number of elements to process
- *  @param[out] min minimum value
- *  @param[out] max maximum value
- */
-template <typename T>
-inline void ArrayBounds(const T* in, unsigned int size, T& min, T& max)
-{
-    MinMaxChooser<T> ()(min,max);
-    for (unsigned int i = 0; i < size;++i) {
-        min = std::min(in[i],min);
-        max = std::max(in[i],max);
-    }
-}
-
-
-// -------------------------------------------------------------------------------
-/** Little helper function to calculate the quadratic difference
- * of two colours.
- * @param pColor1 First color
- * @param pColor2 second color
- * @return Quadratic color difference */
-inline ai_real GetColorDifference( const aiColor4D& pColor1, const aiColor4D& pColor2)
-{
-    const aiColor4D c (pColor1.r - pColor2.r, pColor1.g - pColor2.g, pColor1.b - pColor2.b, pColor1.a - pColor2.a);
-    return c.r*c.r + c.g*c.g + c.b*c.b + c.a*c.a;
-}
-
-
-// -------------------------------------------------------------------------------
-/** @brief Extract single strings from a list of identifiers
- *  @param in Input string list.
- *  @param out Receives a list of clean output strings
- *  @sdee #AI_CONFIG_PP_OG_EXCLUDE_LIST */
-void ConvertListToStrings(const std::string& in, std::list<std::string>& out);
-
-
-// -------------------------------------------------------------------------------
-/** @brief Compute the AABB of a mesh after applying a given transform
- *  @param mesh Input mesh
- *  @param[out] min Receives minimum transformed vertex
- *  @param[out] max Receives maximum transformed vertex
- *  @param m Transformation matrix to be applied */
-void FindAABBTransformed (const aiMesh* mesh, aiVector3D& min, aiVector3D& max, const aiMatrix4x4& m);
-
-
-// -------------------------------------------------------------------------------
-/** @brief Helper function to determine the 'real' center of a mesh
- *
- *  That is the center of its axis-aligned bounding box.
- *  @param mesh Input mesh
- *  @param[out] min Minimum vertex of the mesh
- *  @param[out] max maximum vertex of the mesh
- *  @param[out] out Center point */
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out, aiVector3D& min, aiVector3D& max);
-
-// -------------------------------------------------------------------------------
-/** @brief Helper function to determine the 'real' center of a scene
- *
- *  That is the center of its axis-aligned bounding box.
- *  @param scene Input scene
- *  @param[out] min Minimum vertex of the scene
- *  @param[out] max maximum vertex of the scene
- *  @param[out] out Center point */
-void FindSceneCenter (aiScene* scene, aiVector3D& out, aiVector3D& min, aiVector3D& max);
-
-
-// -------------------------------------------------------------------------------
-// Helper function to determine the 'real' center of a mesh after applying a given transform
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out, aiVector3D& min,aiVector3D& max, const aiMatrix4x4& m);
-
-
-// -------------------------------------------------------------------------------
-// Helper function to determine the 'real' center of a mesh
-void FindMeshCenter (aiMesh* mesh, aiVector3D& out);
-
-
-// -------------------------------------------------------------------------------
-// Helper function to determine the 'real' center of a mesh after applying a given transform
-void FindMeshCenterTransformed (aiMesh* mesh, aiVector3D& out,const aiMatrix4x4& m);
-
-
-// -------------------------------------------------------------------------------
-// Compute a good epsilon value for position comparisons on a mesh
-ai_real ComputePositionEpsilon(const aiMesh* pMesh);
-
-
-// -------------------------------------------------------------------------------
-// Compute a good epsilon value for position comparisons on a array of meshes
-ai_real ComputePositionEpsilon(const aiMesh* const* pMeshes, size_t num);
-
-
-// -------------------------------------------------------------------------------
-// Compute an unique value for the vertex format of a mesh
-unsigned int GetMeshVFormatUnique(const aiMesh* pcMesh);
-
-
-// defs for ComputeVertexBoneWeightTable()
-typedef std::pair <unsigned int,float> PerVertexWeight;
-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);
-
-
-// flags for MakeSubmesh()
-#define AI_SUBMESH_FLAGS_SANS_BONES 0x1
-
-// -------------------------------------------------------------------------------
-// Split a mesh given a list of faces to be contained in the sub mesh
-aiMesh* MakeSubmesh(const aiMesh *superMesh, const std::vector<unsigned int> &subMeshFaces, unsigned int subFlags);
-
-// -------------------------------------------------------------------------------
-// Utility postprocess step to share the spatial sort tree between
-// all steps which use it to speedup its computations.
-class ComputeSpatialSortProcess : public BaseProcess
-{
-    bool IsActive( unsigned int pFlags) const
-    {
-        return NULL != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace |
-            aiProcess_GenNormals | aiProcess_JoinIdenticalVertices));
-    }
-
-    void Execute( aiScene* pScene)
-    {
-        typedef std::pair<SpatialSort, ai_real> _Type;
-        ASSIMP_LOG_DEBUG("Generate spatially-sorted vertex cache");
-
-        std::vector<_Type>* p = new std::vector<_Type>(pScene->mNumMeshes);
-        std::vector<_Type>::iterator it = p->begin();
-
-        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i, ++it) {
-            aiMesh* mesh = pScene->mMeshes[i];
-            _Type& blubb = *it;
-            blubb.first.Fill(mesh->mVertices,mesh->mNumVertices,sizeof(aiVector3D));
-            blubb.second = ComputePositionEpsilon(mesh);
-        }
-
-        shared->AddProperty(AI_SPP_SPATIAL_SORT,p);
-    }
-};
-
-// -------------------------------------------------------------------------------
-// ... and the same again to cleanup the whole stuff
-class DestroySpatialSortProcess : public BaseProcess
-{
-    bool IsActive( unsigned int pFlags) const
-    {
-        return NULL != shared && 0 != (pFlags & (aiProcess_CalcTangentSpace |
-            aiProcess_GenNormals | aiProcess_JoinIdenticalVertices));
-    }
-
-    void Execute( aiScene* /*pScene*/)
-    {
-        shared->RemoveProperty(AI_SPP_SPATIAL_SORT);
-    }
-};
-
-
-
-} // ! namespace Assimp
-#endif // !! AI_PROCESS_HELPER_H_INCLUDED
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp b/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
deleted file mode 100644
index 49ec8f5c47..0000000000
--- a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.cpp
+++ /dev/null
@@ -1,221 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-/** @file RemoveRedundantMaterials.cpp
- *  @brief Implementation of the "RemoveRedundantMaterials" post processing step
-*/
-
-// internal headers
-
-#include "RemoveRedundantMaterials.h"
-#include <assimp/ParsingUtils.h>
-#include "ProcessHelper.h"
-#include "Material/MaterialSystem.h"
-#include <stdio.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-RemoveRedundantMatsProcess::RemoveRedundantMatsProcess()
-: mConfigFixedMaterials() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-RemoveRedundantMatsProcess::~RemoveRedundantMatsProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool RemoveRedundantMatsProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_RemoveRedundantMaterials) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup import properties
-void RemoveRedundantMatsProcess::SetupProperties(const Importer* pImp)
-{
-    // Get value of AI_CONFIG_PP_RRM_EXCLUDE_LIST
-    mConfigFixedMaterials = pImp->GetPropertyString(AI_CONFIG_PP_RRM_EXCLUDE_LIST,"");
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("RemoveRedundantMatsProcess begin");
-
-    unsigned int redundantRemoved = 0, unreferencedRemoved = 0;
-    if (pScene->mNumMaterials)
-    {
-        // Find out which materials are referenced by meshes
-        std::vector<bool> abReferenced(pScene->mNumMaterials,false);
-        for (unsigned int i = 0;i < pScene->mNumMeshes;++i)
-            abReferenced[pScene->mMeshes[i]->mMaterialIndex] = true;
-
-        // If a list of materials to be excluded was given, match the list with
-        // our imported materials and 'salt' all positive matches to ensure that
-        // we get unique hashes later.
-        if (mConfigFixedMaterials.length()) {
-
-            std::list<std::string> strings;
-            ConvertListToStrings(mConfigFixedMaterials,strings);
-
-            for (unsigned int i = 0; i < pScene->mNumMaterials;++i) {
-                aiMaterial* mat = pScene->mMaterials[i];
-
-                aiString name;
-                mat->Get(AI_MATKEY_NAME,name);
-
-                if (name.length) {
-                    std::list<std::string>::const_iterator it = std::find(strings.begin(), strings.end(), name.data);
-                    if (it != strings.end()) {
-
-                        // Our brilliant 'salt': A single material property with ~ as first
-                        // character to mark it as internal and temporary.
-                        const int dummy = 1;
-                        ((aiMaterial*)mat)->AddProperty(&dummy,1,"~RRM.UniqueMaterial",0,0);
-
-                        // Keep this material even if no mesh references it
-                        abReferenced[i] = true;
-                        ASSIMP_LOG_DEBUG_F( "Found positive match in exclusion list: \'", name.data, "\'");
-                    }
-                }
-            }
-        }
-
-        // TODO: re-implement this algorithm to work in-place
-        unsigned int *aiMappingTable = new unsigned int[pScene->mNumMaterials];
-        for ( unsigned int i=0; i<pScene->mNumMaterials; i++ ) {
-            aiMappingTable[ i ] = 0;
-        }
-        unsigned int iNewNum = 0;
-
-        // Iterate through all materials and calculate a hash for them
-        // store all hashes in a list and so a quick search whether
-        // we do already have a specific hash. This allows us to
-        // determine which materials are identical.
-        uint32_t *aiHashes = new uint32_t[ pScene->mNumMaterials ];;
-        for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
-        {
-            // No mesh is referencing this material, remove it.
-            if (!abReferenced[i]) {
-                ++unreferencedRemoved;
-                delete pScene->mMaterials[i];
-                pScene->mMaterials[i] = nullptr;
-                continue;
-            }
-
-            // Check all previously mapped materials for a matching hash.
-            // On a match we can delete this material and just make it ref to the same index.
-            uint32_t me = aiHashes[i] = ComputeMaterialHash(pScene->mMaterials[i]);
-            for (unsigned int a = 0; a < i;++a)
-            {
-                if (abReferenced[a] && me == aiHashes[a]) {
-                    ++redundantRemoved;
-                    me = 0;
-                    aiMappingTable[i] = aiMappingTable[a];
-                    delete pScene->mMaterials[i];
-                    pScene->mMaterials[i] = nullptr;
-                    break;
-                }
-            }
-            // This is a new material that is referenced, add to the map.
-            if (me) {
-                aiMappingTable[i] = iNewNum++;
-            }
-        }
-        // If the new material count differs from the original,
-        // we need to rebuild the material list and remap mesh material indexes.
-        if (iNewNum != pScene->mNumMaterials) {
-            ai_assert(iNewNum > 0);
-            aiMaterial** ppcMaterials = new aiMaterial*[iNewNum];
-            ::memset(ppcMaterials,0,sizeof(void*)*iNewNum);
-            for (unsigned int p = 0; p < pScene->mNumMaterials;++p)
-            {
-                // if the material is not referenced ... remove it
-                if (!abReferenced[p]) {
-                    continue;
-                }
-
-                // generate new names for modified materials that had no names
-                const unsigned int idx = aiMappingTable[p];
-                if (ppcMaterials[idx]) {
-                    aiString sz;
-                    if( ppcMaterials[idx]->Get(AI_MATKEY_NAME, sz) != AI_SUCCESS ) {
-                        sz.length = ::ai_snprintf(sz.data,MAXLEN,"JoinedMaterial_#%u",p);
-                        ((aiMaterial*)ppcMaterials[idx])->AddProperty(&sz,AI_MATKEY_NAME);
-                    }
-                } else {
-                    ppcMaterials[idx] = pScene->mMaterials[p];
-                }
-            }
-            // update all material indices
-            for (unsigned int p = 0; p < pScene->mNumMeshes;++p) {
-                aiMesh* mesh = pScene->mMeshes[p];
-                ai_assert( NULL!=mesh );
-                mesh->mMaterialIndex = aiMappingTable[mesh->mMaterialIndex];
-            }
-            // delete the old material list
-            delete[] pScene->mMaterials;
-            pScene->mMaterials = ppcMaterials;
-            pScene->mNumMaterials = iNewNum;
-        }
-        // delete temporary storage
-        delete[] aiHashes;
-        delete[] aiMappingTable;
-    }
-    if (redundantRemoved == 0 && unreferencedRemoved == 0)
-    {
-        ASSIMP_LOG_DEBUG("RemoveRedundantMatsProcess finished ");
-    }
-    else
-    {
-        ASSIMP_LOG_INFO_F("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ", 
-            unreferencedRemoved, " unused materials.");
-    }
-}
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h b/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h
deleted file mode 100644
index 1f32a0abfb..0000000000
--- a/thirdparty/assimp/code/PostProcessing/RemoveRedundantMaterials.h
+++ /dev/null
@@ -1,103 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file RemoveRedundantMaterials.h
- *  @brief Defines a post processing step to remove redundant materials
- */
-#ifndef AI_REMOVEREDUNDANTMATERIALS_H_INC
-#define AI_REMOVEREDUNDANTMATERIALS_H_INC
-
-#include "Common/BaseProcess.h"
-#include <assimp/mesh.h>
-
-class RemoveRedundantMatsTest;
-
-namespace Assimp    {
-
-// ---------------------------------------------------------------------------
-/** RemoveRedundantMatsProcess: Post-processing step to remove redundant
- *  materials from the imported scene.
- */
-class ASSIMP_API RemoveRedundantMatsProcess : public BaseProcess {
-public:
-    /// The default class constructor.
-    RemoveRedundantMatsProcess();
-
-    /// The class destructor.
-    ~RemoveRedundantMatsProcess();
-
-    // -------------------------------------------------------------------
-    // Check whether step is active
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    // Execute step on a given scene
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    // Setup import settings
-    void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    /** @brief Set list of fixed (inmutable) materials
-     *  @param fixed See #AI_CONFIG_PP_RRM_EXCLUDE_LIST
-     */
-    void SetFixedMaterialsString(const std::string& fixed = "") {
-        mConfigFixedMaterials = fixed;
-    }
-
-    // -------------------------------------------------------------------
-    /** @brief Get list of fixed (inmutable) materials
-     *  @return See #AI_CONFIG_PP_RRM_EXCLUDE_LIST
-     */
-    const std::string& GetFixedMaterialsString() const {
-        return mConfigFixedMaterials;
-    }
-
-private:
-    //! Configuration option: list of all fixed materials
-    std::string mConfigFixedMaterials;
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_REMOVEREDUNDANTMATERIALS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp b/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp
deleted file mode 100644
index 99fd47a3aa..0000000000
--- a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.cpp
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-/** @file Implementation of the post processing step to remove
- *        any parts of the mesh structure from the imported data.
-*/
-
-
-#include "RemoveVCProcess.h"
-#include <assimp/postprocess.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-RemoveVCProcess::RemoveVCProcess() :
-    configDeleteFlags()
-  , mScene()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-RemoveVCProcess::~RemoveVCProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool RemoveVCProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_RemoveComponent) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Small helper function to delete all elements in a T** aray using delete
-template <typename T>
-inline void ArrayDelete(T**& in, unsigned int& num)
-{
-    for (unsigned int i = 0; i < num; ++i)
-        delete in[i];
-
-    delete[] in;
-    in = NULL;
-    num = 0;
-}
-
-#if 0
-// ------------------------------------------------------------------------------------------------
-// Updates the node graph - removes all nodes which have the "remove" flag set and the
-// "don't remove" flag not set. Nodes with meshes are never deleted.
-bool UpdateNodeGraph(aiNode* node,std::list<aiNode*>& childsOfParent,bool root)
-{
-    bool b = false;
-
-    std::list<aiNode*> mine;
-    for (unsigned int i = 0; i < node->mNumChildren;++i)
-    {
-        if(UpdateNodeGraph(node->mChildren[i],mine,false))
-            b = true;
-    }
-
-    // somewhat tricky ... mNumMeshes must be originally 0 and MSB2 may not be set,
-    // so we can do a simple comparison against MSB here
-    if (!root && AI_RC_UINT_MSB == node->mNumMeshes )
-    {
-        // this node needs to be removed
-        if(node->mNumChildren)
-        {
-            childsOfParent.insert(childsOfParent.end(),mine.begin(),mine.end());
-
-            // set all children to NULL to make sure they are not deleted when we delete ourself
-            for (unsigned int i = 0; i < node->mNumChildren;++i)
-                node->mChildren[i] = NULL;
-        }
-        b = true;
-        delete node;
-    }
-    else
-    {
-        AI_RC_UNMASK(node->mNumMeshes);
-        childsOfParent.push_back(node);
-
-        if (b)
-        {
-            // reallocate the array of our children here
-            node->mNumChildren = (unsigned int)mine.size();
-            aiNode** const children = new aiNode*[mine.size()];
-            aiNode** ptr = children;
-
-            for (std::list<aiNode*>::iterator it = mine.begin(), end = mine.end();
-                 it != end; ++it)
-            {
-                *ptr++ = *it;
-            }
-            delete[] node->mChildren;
-            node->mChildren = children;
-            return false;
-        }
-    }
-    return b;
-}
-#endif
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void RemoveVCProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("RemoveVCProcess begin");
-    bool bHas = false; //,bMasked = false;
-
-    mScene = pScene;
-
-    // handle animations
-    if ( configDeleteFlags & aiComponent_ANIMATIONS)
-    {
-
-        bHas = true;
-        ArrayDelete(pScene->mAnimations,pScene->mNumAnimations);
-    }
-
-    // handle textures
-    if ( configDeleteFlags & aiComponent_TEXTURES)
-    {
-        bHas = true;
-        ArrayDelete(pScene->mTextures,pScene->mNumTextures);
-    }
-
-    // handle materials
-    if ( configDeleteFlags & aiComponent_MATERIALS && pScene->mNumMaterials)
-    {
-        bHas = true;
-        for (unsigned int i = 1;i < pScene->mNumMaterials;++i)
-            delete pScene->mMaterials[i];
-
-        pScene->mNumMaterials = 1;
-        aiMaterial* helper = (aiMaterial*) pScene->mMaterials[0];
-        ai_assert(NULL != helper);
-        helper->Clear();
-
-        // gray
-        aiColor3D clr(0.6f,0.6f,0.6f);
-        helper->AddProperty(&clr,1,AI_MATKEY_COLOR_DIFFUSE);
-
-        // add a small ambient color value
-        clr = aiColor3D(0.05f,0.05f,0.05f);
-        helper->AddProperty(&clr,1,AI_MATKEY_COLOR_AMBIENT);
-
-        aiString s;
-        s.Set("Dummy_MaterialsRemoved");
-        helper->AddProperty(&s,AI_MATKEY_NAME);
-    }
-
-    // handle light sources
-    if ( configDeleteFlags & aiComponent_LIGHTS)
-    {
-        bHas =  true;
-        ArrayDelete(pScene->mLights,pScene->mNumLights);
-    }
-
-    // handle camneras
-    if ( configDeleteFlags & aiComponent_CAMERAS)
-    {
-        bHas = true;
-        ArrayDelete(pScene->mCameras,pScene->mNumCameras);
-    }
-
-    // handle meshes
-    if (configDeleteFlags & aiComponent_MESHES)
-    {
-        bHas = true;
-        ArrayDelete(pScene->mMeshes,pScene->mNumMeshes);
-    }
-    else
-    {
-        for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-        {
-            if( ProcessMesh( pScene->mMeshes[a]))
-                bHas = true;
-        }
-    }
-
-
-    // now check whether the result is still a full scene
-    if (!pScene->mNumMeshes || !pScene->mNumMaterials)
-    {
-        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
-        ASSIMP_LOG_DEBUG("Setting AI_SCENE_FLAGS_INCOMPLETE flag");
-
-        // If we have no meshes anymore we should also clear another flag ...
-        if (!pScene->mNumMeshes)
-            pScene->mFlags &= ~AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
-    }
-
-    if (bHas) {
-        ASSIMP_LOG_INFO("RemoveVCProcess finished. Data structure cleanup has been done.");
-    } else {
-        ASSIMP_LOG_DEBUG("RemoveVCProcess finished. Nothing to be done ...");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties for the step
-void RemoveVCProcess::SetupProperties(const Importer* pImp)
-{
-    configDeleteFlags = pImp->GetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS,0x0);
-    if (!configDeleteFlags)
-    {
-        ASSIMP_LOG_WARN("RemoveVCProcess: AI_CONFIG_PP_RVC_FLAGS is zero.");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-bool RemoveVCProcess::ProcessMesh(aiMesh* pMesh)
-{
-    bool ret = false;
-
-    // if all materials have been deleted let the material
-    // index of the mesh point to the created default material
-    if ( configDeleteFlags & aiComponent_MATERIALS)
-        pMesh->mMaterialIndex = 0;
-
-    // handle normals
-    if (configDeleteFlags & aiComponent_NORMALS && pMesh->mNormals)
-    {
-        delete[] pMesh->mNormals;
-        pMesh->mNormals = NULL;
-        ret = true;
-    }
-
-    // handle tangents and bitangents
-    if (configDeleteFlags & aiComponent_TANGENTS_AND_BITANGENTS && pMesh->mTangents)
-    {
-        delete[] pMesh->mTangents;
-        pMesh->mTangents = NULL;
-
-        delete[] pMesh->mBitangents;
-        pMesh->mBitangents = NULL;
-        ret = true;
-    }
-
-    // handle texture coordinates
-    bool b = (0 != (configDeleteFlags & aiComponent_TEXCOORDS));
-    for (unsigned int i = 0, real = 0; real < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++real)
-    {
-        if (!pMesh->mTextureCoords[i])break;
-        if (configDeleteFlags & aiComponent_TEXCOORDSn(real) || b)
-        {
-            delete [] pMesh->mTextureCoords[i];
-            pMesh->mTextureCoords[i] = NULL;
-            ret = true;
-
-            if (!b)
-            {
-                // collapse the rest of the array
-                for (unsigned int a = i+1; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a)
-                    pMesh->mTextureCoords[a-1] = pMesh->mTextureCoords[a];
-
-                pMesh->mTextureCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS-1] = NULL;
-                continue;
-            }
-        }
-        ++i;
-    }
-
-    // handle vertex colors
-    b = (0 != (configDeleteFlags & aiComponent_COLORS));
-    for (unsigned int i = 0, real = 0; real < AI_MAX_NUMBER_OF_COLOR_SETS; ++real)
-    {
-        if (!pMesh->mColors[i])break;
-        if (configDeleteFlags & aiComponent_COLORSn(i) || b)
-        {
-            delete [] pMesh->mColors[i];
-            pMesh->mColors[i] = NULL;
-            ret = true;
-
-            if (!b)
-            {
-                // collapse the rest of the array
-                for (unsigned int a = i+1; a < AI_MAX_NUMBER_OF_COLOR_SETS;++a)
-                    pMesh->mColors[a-1] = pMesh->mColors[a];
-
-                pMesh->mColors[AI_MAX_NUMBER_OF_COLOR_SETS-1] = NULL;
-                continue;
-            }
-        }
-        ++i;
-    }
-
-    // handle bones
-    if (configDeleteFlags & aiComponent_BONEWEIGHTS && pMesh->mBones)
-    {
-        ArrayDelete(pMesh->mBones,pMesh->mNumBones);
-        ret = true;
-    }
-    return ret;
-}
diff --git a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h b/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h
deleted file mode 100644
index 7bb21a8330..0000000000
--- a/thirdparty/assimp/code/PostProcessing/RemoveVCProcess.h
+++ /dev/null
@@ -1,124 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to remove specific parts of the scene */
-#ifndef AI_REMOVEVCPROCESS_H_INCLUDED
-#define AI_REMOVEVCPROCESS_H_INCLUDED
-
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-
-class RemoveVCProcessTest;
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** RemoveVCProcess: Class to exclude specific parts of the data structure
- *  from further processing by removing them,
-*/
-class ASSIMP_API RemoveVCProcess : public BaseProcess {
-public:
-    /// The default class constructor.
-    RemoveVCProcess();
-
-    /// The class destructor.
-    ~RemoveVCProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-    * @param pFlags The processing flags the importer was called with. A bitwise
-    *   combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    virtual void SetupProperties(const Importer* pImp);
-
-    // -------------------------------------------------------------------
-    /** Manually setup the configuration flags for the step
-     *
-     *  @param Bitwise combination of the #aiComponent enumerated values.
-    */
-    void SetDeleteFlags(unsigned int f)
-    {
-        configDeleteFlags = f;
-    }
-
-    // -------------------------------------------------------------------
-    /** Query the current configuration.
-    */
-    unsigned int GetDeleteFlags() const
-    {
-        return configDeleteFlags;
-    }
-
-private:
-
-    bool ProcessMesh (aiMesh* pcMesh);
-
-    /** Configuration flag
-     */
-    unsigned int configDeleteFlags;
-
-    /** The scene we're working with
-     */
-    aiScene* mScene;
-};
-
-// ---------------------------------------------------------------------------
-
-} // end of namespace Assimp
-
-#endif // !!AI_REMOVEVCPROCESS_H_INCLUDED
diff --git a/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp b/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp
deleted file mode 100644
index ac770c41f2..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ScaleProcess.cpp
+++ /dev/null
@@ -1,208 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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 "ScaleProcess.h"
-
-#include <assimp/scene.h>
-#include <assimp/postprocess.h>
-#include <assimp/BaseImporter.h>
-
-namespace Assimp {
-
-ScaleProcess::ScaleProcess()
-: BaseProcess()
-, mScale( AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT ) {
-}
-
-ScaleProcess::~ScaleProcess() {
-    // empty
-}
-
-void ScaleProcess::setScale( ai_real scale ) {
-    mScale = scale;
-}
-
-ai_real ScaleProcess::getScale() const {
-    return mScale;
-}
-
-bool ScaleProcess::IsActive( unsigned int pFlags ) const {
-    return ( pFlags & aiProcess_GlobalScale ) != 0;
-}
-
-void ScaleProcess::SetupProperties( const Importer* pImp ) {
-    // User scaling
-    mScale = pImp->GetPropertyFloat( AI_CONFIG_GLOBAL_SCALE_FACTOR_KEY, 1.0f );
-
-    // File scaling * Application Scaling
-    float importerScale = pImp->GetPropertyFloat( AI_CONFIG_APP_SCALE_KEY, 1.0f );
-
-    // apply scale to the scale 
-    // helps prevent bugs with backward compatibility for anyone using normal scaling.
-    mScale *= importerScale;
-}
-
-void ScaleProcess::Execute( aiScene* pScene ) {
-    if(mScale == 1.0f)  {
-        return; // nothing to scale
-    }
-    
-    ai_assert( mScale != 0 );
-    ai_assert( nullptr != pScene );
-    ai_assert( nullptr != pScene->mRootNode );
-
-    if ( nullptr == pScene ) {
-        return;
-    }
-
-    if ( nullptr == pScene->mRootNode ) {
-        return;
-    }
-    
-    // Process animations and update position transform to new unit system
-    for( unsigned int animationID = 0; animationID < pScene->mNumAnimations; animationID++ )
-    {
-        aiAnimation* animation = pScene->mAnimations[animationID];
-
-        for( unsigned int animationChannel = 0; animationChannel < animation->mNumChannels; animationChannel++)
-        {
-            aiNodeAnim* anim = animation->mChannels[animationChannel];
-            
-            for( unsigned int posKey = 0; posKey < anim->mNumPositionKeys; posKey++)
-            {
-                aiVectorKey& vectorKey = anim->mPositionKeys[posKey];
-                vectorKey.mValue *= mScale;
-            }
-        }
-    }
-
-    for( unsigned int meshID = 0; meshID < pScene->mNumMeshes; meshID++)
-    {
-        aiMesh *mesh = pScene->mMeshes[meshID]; 
-        
-        // Reconstruct mesh vertexes to the new unit system
-        for( unsigned int vertexID = 0; vertexID < mesh->mNumVertices; vertexID++)
-        {
-            aiVector3D& vertex = mesh->mVertices[vertexID];
-            vertex *= mScale;
-        }
-
-
-        // bone placement / scaling
-        for( unsigned int boneID = 0; boneID < mesh->mNumBones; boneID++)
-        {
-            // Reconstruct matrix by transform rather than by scale 
-            // This prevent scale values being changed which can
-            // be meaningful in some cases 
-            // like when you want the modeller to see 1:1 compatibility.
-            aiBone* bone = mesh->mBones[boneID];
-
-            aiVector3D pos, scale;
-            aiQuaternion rotation;
-
-            bone->mOffsetMatrix.Decompose( scale, rotation, pos);
-            
-            aiMatrix4x4 translation;
-            aiMatrix4x4::Translation( pos * mScale, translation );
-            
-            aiMatrix4x4 scaling;
-            aiMatrix4x4::Scaling( aiVector3D(scale), scaling );
-
-            aiMatrix4x4 RotMatrix = aiMatrix4x4 (rotation.GetMatrix());
-
-            bone->mOffsetMatrix = translation * RotMatrix * scaling;
-        }
-
-
-        // animation mesh processing
-        // convert by position rather than scale.
-        for( unsigned int animMeshID = 0; animMeshID < mesh->mNumAnimMeshes; animMeshID++)
-        {
-            aiAnimMesh * animMesh = mesh->mAnimMeshes[animMeshID];
-            
-            for( unsigned int vertexID = 0; vertexID < animMesh->mNumVertices; vertexID++)
-            {
-                aiVector3D& vertex = animMesh->mVertices[vertexID];
-                vertex *= mScale;
-            }
-        }
-    }
-
-    traverseNodes( pScene->mRootNode );
-}
-
-void ScaleProcess::traverseNodes( aiNode *node, unsigned int nested_node_id ) {    
-    applyScaling( node );
-
-    for( size_t i = 0; i < node->mNumChildren; i++)
-    {
-        // recurse into the tree until we are done!
-        traverseNodes( node->mChildren[i], nested_node_id+1 ); 
-    }
-}
-
-void ScaleProcess::applyScaling( aiNode *currentNode ) {
-    if ( nullptr != currentNode ) {
-        // Reconstruct matrix by transform rather than by scale 
-        // This prevent scale values being changed which can
-        // be meaningful in some cases 
-        // like when you want the modeller to 
-        // see 1:1 compatibility.
-        
-        aiVector3D pos, scale;
-        aiQuaternion rotation;
-        currentNode->mTransformation.Decompose( scale, rotation, pos);
-        
-        aiMatrix4x4 translation;
-        aiMatrix4x4::Translation( pos * mScale, translation );
-        
-        aiMatrix4x4 scaling;
-
-        // note: we do not use mScale here, this is on purpose.
-        aiMatrix4x4::Scaling( scale, scaling );
-
-        aiMatrix4x4 RotMatrix = aiMatrix4x4 (rotation.GetMatrix());
-
-        currentNode->mTransformation = translation * RotMatrix * scaling;
-    }
-}
-
-} // Namespace Assimp
diff --git a/thirdparty/assimp/code/PostProcessing/ScaleProcess.h b/thirdparty/assimp/code/PostProcessing/ScaleProcess.h
deleted file mode 100644
index 468a216736..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ScaleProcess.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-#ifndef SCALE_PROCESS_H_
-#define SCALE_PROCESS_H_
-
-#include "Common/BaseProcess.h"
-
-struct aiNode;
-
-#if (!defined AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT)
-#   define AI_CONFIG_GLOBAL_SCALE_FACTOR_DEFAULT  1.0f
-#endif // !! AI_DEBONE_THRESHOLD
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** ScaleProcess: Class to rescale the whole model.
- * Now rescales animations, bones, and blend shapes properly.
- * Please note this will not write to 'scale' transform it will rewrite mesh 
- * and matrixes so that your scale values 
- * from your model package are preserved, so this is completely intentional
- * bugs should be reported as soon as they are found.
-*/
-class ASSIMP_API ScaleProcess : public BaseProcess {
-public:
-    /// The default class constructor.
-    ScaleProcess();
-
-    /// The class destructor.
-    virtual ~ScaleProcess();
-
-    /// Will set the scale manually.
-    void setScale( ai_real scale );
-
-    /// Returns the current scaling value.
-    ai_real getScale() const;
-
-    /// Overwritten, @see BaseProcess
-    virtual bool IsActive( unsigned int pFlags ) const;
-
-    /// Overwritten, @see BaseProcess
-    virtual void SetupProperties( const Importer* pImp );
-
-    /// Overwritten, @see BaseProcess
-    virtual void Execute( aiScene* pScene );
-
-private:
-    void traverseNodes( aiNode *currentNode, unsigned int nested_node_id = 0 );
-    void applyScaling( aiNode *currentNode );
-
-private:
-    ai_real mScale;
-};
-
-} // Namespace Assimp
-
-
-#endif // SCALE_PROCESS_H_
\ No newline at end of file
diff --git a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp b/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp
deleted file mode 100644
index be8405a17b..0000000000
--- a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.cpp
+++ /dev/null
@@ -1,403 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file Implementation of the DeterminePTypeHelperProcess and
- *  SortByPTypeProcess post-process steps.
-*/
-
-
-
-// internal headers
-#include "ProcessHelper.h"
-#include "SortByPTypeProcess.h"
-#include <assimp/Exceptional.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-SortByPTypeProcess::SortByPTypeProcess()
-: mConfigRemoveMeshes( 0 ) {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-SortByPTypeProcess::~SortByPTypeProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool SortByPTypeProcess::IsActive( unsigned int pFlags) const
-{
-    return  (pFlags & aiProcess_SortByPType) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-void SortByPTypeProcess::SetupProperties(const Importer* pImp)
-{
-    mConfigRemoveMeshes = pImp->GetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE,0);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Update changed meshes in all nodes
-void UpdateNodes(const std::vector<unsigned int>& replaceMeshIndex, aiNode* node)
-{
-    if (node->mNumMeshes)
-    {
-        unsigned int newSize = 0;
-        for (unsigned int m = 0; m< node->mNumMeshes; ++m)
-        {
-            unsigned int add = node->mMeshes[m]<<2;
-            for (unsigned int i = 0; i < 4;++i)
-            {
-                if (UINT_MAX != replaceMeshIndex[add+i])++newSize;
-            }
-        }
-        if (!newSize)
-        {
-            delete[] node->mMeshes;
-            node->mNumMeshes = 0;
-            node->mMeshes    = NULL;
-        }
-        else
-        {
-            // Try to reuse the old array if possible
-            unsigned int* newMeshes = (newSize > node->mNumMeshes
-                ? new unsigned int[newSize] : node->mMeshes);
-
-            for (unsigned int m = 0; m< node->mNumMeshes; ++m)
-            {
-                unsigned int add = node->mMeshes[m]<<2;
-                for (unsigned int i = 0; i < 4;++i)
-                {
-                    if (UINT_MAX != replaceMeshIndex[add+i])
-                        *newMeshes++ = replaceMeshIndex[add+i];
-                }
-            }
-            if (newSize > node->mNumMeshes)
-                delete[] node->mMeshes;
-
-            node->mMeshes = newMeshes-(node->mNumMeshes = newSize);
-        }
-    }
-
-    // call all subnodes recursively
-    for (unsigned int m = 0; m < node->mNumChildren; ++m)
-        UpdateNodes(replaceMeshIndex,node->mChildren[m]);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void SortByPTypeProcess::Execute( aiScene* pScene) {
-    if ( 0 == pScene->mNumMeshes) {
-        ASSIMP_LOG_DEBUG("SortByPTypeProcess skipped, there are no meshes");
-        return;
-    }
-
-    ASSIMP_LOG_DEBUG("SortByPTypeProcess begin");
-
-    unsigned int aiNumMeshesPerPType[4] = {0,0,0,0};
-
-    std::vector<aiMesh*> outMeshes;
-    outMeshes.reserve(pScene->mNumMeshes<<1u);
-
-    bool bAnyChanges = false;
-
-    std::vector<unsigned int> replaceMeshIndex(pScene->mNumMeshes*4,UINT_MAX);
-    std::vector<unsigned int>::iterator meshIdx = replaceMeshIndex.begin();
-    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
-        aiMesh* const mesh = pScene->mMeshes[i];
-        ai_assert(0 != mesh->mPrimitiveTypes);
-
-        // if there's just one primitive type in the mesh there's nothing to do for us
-        unsigned int num = 0;
-        if (mesh->mPrimitiveTypes & aiPrimitiveType_POINT) {
-            ++aiNumMeshesPerPType[0];
-            ++num;
-        }
-        if (mesh->mPrimitiveTypes & aiPrimitiveType_LINE) {
-            ++aiNumMeshesPerPType[1];
-            ++num;
-        }
-        if (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE) {
-            ++aiNumMeshesPerPType[2];
-            ++num;
-        }
-        if (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON) {
-            ++aiNumMeshesPerPType[3];
-            ++num;
-        }
-
-        if (1 == num) {
-            if (!(mConfigRemoveMeshes & mesh->mPrimitiveTypes)) {
-                *meshIdx = static_cast<unsigned int>( outMeshes.size() );
-                outMeshes.push_back(mesh);
-            } else {
-                delete mesh;
-                pScene->mMeshes[ i ] = nullptr;
-                bAnyChanges = true;
-            }
-
-            meshIdx += 4;
-            continue;
-        }
-        bAnyChanges = true;
-
-        // reuse our current mesh arrays for the submesh
-        // with the largest number of primitives
-        unsigned int aiNumPerPType[4] = {0,0,0,0};
-        aiFace* pFirstFace = mesh->mFaces;
-        aiFace* const pLastFace = pFirstFace + mesh->mNumFaces;
-
-        unsigned int numPolyVerts = 0;
-        for (;pFirstFace != pLastFace; ++pFirstFace) {
-            if (pFirstFace->mNumIndices <= 3)
-                ++aiNumPerPType[pFirstFace->mNumIndices-1];
-            else
-            {
-                ++aiNumPerPType[3];
-                numPolyVerts += pFirstFace-> mNumIndices;
-            }
-        }
-
-        VertexWeightTable* avw = ComputeVertexBoneWeightTable(mesh);
-        for (unsigned int real = 0; real < 4; ++real,++meshIdx)
-        {
-            if ( !aiNumPerPType[real] || mConfigRemoveMeshes & (1u << real))
-            {
-                continue;
-            }
-
-            *meshIdx = (unsigned int) outMeshes.size();
-            outMeshes.push_back(new aiMesh());
-            aiMesh* out = outMeshes.back();
-
-            // the name carries the adjacency information between the meshes
-            out->mName = mesh->mName;
-
-            // copy data members
-            out->mPrimitiveTypes = 1u << real;
-            out->mMaterialIndex = mesh->mMaterialIndex;
-
-            // allocate output storage
-            out->mNumFaces = aiNumPerPType[real];
-            aiFace* outFaces = out->mFaces = new aiFace[out->mNumFaces];
-
-            out->mNumVertices = (3 == real ? numPolyVerts : out->mNumFaces * (real+1));
-
-            aiVector3D *vert(nullptr), *nor(nullptr), *tan(nullptr), *bit(nullptr);
-            aiVector3D *uv   [AI_MAX_NUMBER_OF_TEXTURECOORDS];
-            aiColor4D  *cols [AI_MAX_NUMBER_OF_COLOR_SETS];
-
-            if (mesh->mVertices) {
-                vert = out->mVertices = new aiVector3D[out->mNumVertices];
-            }
-
-            if (mesh->mNormals) {
-                nor = out->mNormals = new aiVector3D[out->mNumVertices];
-            }
-
-            if (mesh->mTangents) {
-                tan = out->mTangents   = new aiVector3D[out->mNumVertices];
-                bit = out->mBitangents = new aiVector3D[out->mNumVertices];
-            }
-
-            for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_TEXTURECOORDS;++j) {
-                uv[j] = nullptr;
-                if (mesh->mTextureCoords[j]) {
-                    uv[j] = out->mTextureCoords[j] = new aiVector3D[out->mNumVertices];
-                }
-
-                out->mNumUVComponents[j] = mesh->mNumUVComponents[j];
-            }
-
-            for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_COLOR_SETS;++j) {
-                cols[j] = nullptr;
-                if (mesh->mColors[j]) {
-                    cols[j] = out->mColors[j] = new aiColor4D[out->mNumVertices];
-                }
-            }
-
-            typedef std::vector< aiVertexWeight > TempBoneInfo;
-            std::vector< TempBoneInfo > tempBones(mesh->mNumBones);
-
-            // try to guess how much storage we'll need
-            for (unsigned int q = 0; q < mesh->mNumBones;++q)
-            {
-                tempBones[q].reserve(mesh->mBones[q]->mNumWeights / (num-1));
-            }
-
-            unsigned int outIdx = 0;
-            for (unsigned int m = 0; m < mesh->mNumFaces; ++m)
-            {
-                aiFace& in = mesh->mFaces[m];
-                if ((real == 3  && in.mNumIndices <= 3) || (real != 3 && in.mNumIndices != real+1))
-                {
-                    continue;
-                }
-
-                outFaces->mNumIndices = in.mNumIndices;
-                outFaces->mIndices    = in.mIndices;
-
-                for (unsigned int q = 0; q < in.mNumIndices; ++q)
-                {
-                    unsigned int idx = in.mIndices[q];
-
-                    // process all bones of this index
-                    if (avw)
-                    {
-                        VertexWeightTable& tbl = avw[idx];
-                        for (VertexWeightTable::const_iterator it = tbl.begin(), end = tbl.end();
-                             it != end; ++it)
-                        {
-                            tempBones[ (*it).first ].push_back( aiVertexWeight(outIdx, (*it).second) );
-                        }
-                    }
-
-                    if (vert)
-                    {
-                        *vert++ = mesh->mVertices[idx];
-                        //mesh->mVertices[idx].x = get_qnan();
-                    }
-                    if (nor )*nor++  = mesh->mNormals[idx];
-                    if (tan )
-                    {
-                        *tan++  = mesh->mTangents[idx];
-                        *bit++  = mesh->mBitangents[idx];
-                    }
-
-                    for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++pp)
-                    {
-                        if (!uv[pp])break;
-                        *uv[pp]++ = mesh->mTextureCoords[pp][idx];
-                    }
-
-                    for (unsigned int pp = 0; pp < AI_MAX_NUMBER_OF_COLOR_SETS; ++pp)
-                    {
-                        if (!cols[pp])break;
-                        *cols[pp]++ = mesh->mColors[pp][idx];
-                    }
-
-                    in.mIndices[q] = outIdx++;
-                }
-
-                in.mIndices = nullptr;
-                ++outFaces;
-            }
-            ai_assert(outFaces == out->mFaces + out->mNumFaces);
-
-            // now generate output bones
-            for (unsigned int q = 0; q < mesh->mNumBones;++q)
-                if (!tempBones[q].empty())++out->mNumBones;
-
-            if (out->mNumBones)
-            {
-                out->mBones = new aiBone*[out->mNumBones];
-                for (unsigned int q = 0, real = 0; q < mesh->mNumBones;++q)
-                {
-                    TempBoneInfo& in = tempBones[q];
-                    if (in.empty())continue;
-
-                    aiBone* srcBone = mesh->mBones[q];
-                    aiBone* bone = out->mBones[real] = new aiBone();
-
-                    bone->mName = srcBone->mName;
-                    bone->mOffsetMatrix = srcBone->mOffsetMatrix;
-
-                    bone->mNumWeights = (unsigned int)in.size();
-                    bone->mWeights = new aiVertexWeight[bone->mNumWeights];
-
-                    ::memcpy(bone->mWeights,&in[0],bone->mNumWeights*sizeof(aiVertexWeight));
-
-                    ++real;
-                }
-            }
-        }
-
-        // delete the per-vertex bone weights table
-        delete[] avw;
-
-        // delete the input mesh
-        delete mesh;
-
-        // avoid invalid pointer
-        pScene->mMeshes[i] = NULL;
-    }
-
-    if (outMeshes.empty())
-    {
-        // This should not occur
-        throw DeadlyImportError("No meshes remaining");
-    }
-
-    // If we added at least one mesh process all nodes in the node
-    // graph and update their respective mesh indices.
-    if (bAnyChanges)
-    {
-        UpdateNodes(replaceMeshIndex,pScene->mRootNode);
-    }
-
-    if (outMeshes.size() != pScene->mNumMeshes)
-    {
-        delete[] pScene->mMeshes;
-        pScene->mNumMeshes = (unsigned int)outMeshes.size();
-        pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-    }
-    ::memcpy(pScene->mMeshes,&outMeshes[0],pScene->mNumMeshes*sizeof(void*));
-
-    if (!DefaultLogger::isNullLogger())
-    {
-        char buffer[1024];
-        ::ai_snprintf(buffer,1024,"Points: %u%s, Lines: %u%s, Triangles: %u%s, Polygons: %u%s (Meshes, X = removed)",
-            aiNumMeshesPerPType[0], ((mConfigRemoveMeshes & aiPrimitiveType_POINT)     ? "X" : ""),
-            aiNumMeshesPerPType[1], ((mConfigRemoveMeshes & aiPrimitiveType_LINE)      ? "X" : ""),
-            aiNumMeshesPerPType[2], ((mConfigRemoveMeshes & aiPrimitiveType_TRIANGLE)  ? "X" : ""),
-            aiNumMeshesPerPType[3], ((mConfigRemoveMeshes & aiPrimitiveType_POLYGON)   ? "X" : ""));
-        ASSIMP_LOG_INFO(buffer);
-        ASSIMP_LOG_DEBUG("SortByPTypeProcess finished");
-    }
-}
-
diff --git a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h b/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h
deleted file mode 100644
index 1d7ccfc152..0000000000
--- a/thirdparty/assimp/code/PostProcessing/SortByPTypeProcess.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to sort meshes by the types
-    of primitives they contain */
-#ifndef AI_SORTBYPTYPEPROCESS_H_INC
-#define AI_SORTBYPTYPEPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-#include <assimp/mesh.h>
-
-class SortByPTypeProcessTest;
-
-namespace Assimp    {
-
-
-// ---------------------------------------------------------------------------
-/** SortByPTypeProcess: Sorts meshes by the types of primitives they contain.
- *  A mesh with 5 lines, 3 points and 145 triangles would be split in 3
- * submeshes.
-*/
-class ASSIMP_API SortByPTypeProcess : public BaseProcess {
-public:
-    SortByPTypeProcess();
-    ~SortByPTypeProcess();
-
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
-
-private:
-    int mConfigRemoveMeshes;
-};
-
-
-} // end of namespace Assimp
-
-#endif // !!AI_SORTBYPTYPEPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp b/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp
deleted file mode 100644
index 1797b28d5a..0000000000
--- a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.cpp
+++ /dev/null
@@ -1,623 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** 
- *  @file Implementation of the SplitLargeMeshes postprocessing step
- */
-
-// internal headers of the post-processing framework
-#include "SplitLargeMeshes.h"
-#include "ProcessHelper.h"
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Triangle::SplitLargeMeshesProcess_Triangle() {
-    LIMIT = AI_SLM_DEFAULT_MAX_TRIANGLES;
-}
-
-// ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Triangle::~SplitLargeMeshesProcess_Triangle() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool SplitLargeMeshesProcess_Triangle::IsActive( unsigned int pFlags) const {
-    return (pFlags & aiProcess_SplitLargeMeshes) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void SplitLargeMeshesProcess_Triangle::Execute( aiScene* pScene) {
-    if (0xffffffff == this->LIMIT || nullptr == pScene ) {
-        return;
-    }
-
-    ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Triangle begin");
-    std::vector<std::pair<aiMesh*, unsigned int> > avList;
-
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
-        this->SplitMesh(a, pScene->mMeshes[a],avList);
-    }
-
-    if (avList.size() != pScene->mNumMeshes) {
-        // it seems something has been split. rebuild the mesh list
-        delete[] pScene->mMeshes;
-        pScene->mNumMeshes = (unsigned int)avList.size();
-        pScene->mMeshes = new aiMesh*[avList.size()];
-
-        for (unsigned int i = 0; i < avList.size();++i) {
-            pScene->mMeshes[i] = avList[i].first;
-        }
-
-        // now we need to update all nodes
-        this->UpdateNode(pScene->mRootNode,avList);
-        ASSIMP_LOG_INFO("SplitLargeMeshesProcess_Triangle finished. Meshes have been split");
-    } else {
-        ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Triangle finished. There was nothing to do");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup properties
-void SplitLargeMeshesProcess_Triangle::SetupProperties( const Importer* pImp) {
-    // get the current value of the split property
-    this->LIMIT = pImp->GetPropertyInteger(AI_CONFIG_PP_SLM_TRIANGLE_LIMIT,AI_SLM_DEFAULT_MAX_TRIANGLES);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Update a node after some meshes have been split
-void SplitLargeMeshesProcess_Triangle::UpdateNode(aiNode* pcNode,
-        const std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
-    // for every index in out list build a new entry
-    std::vector<unsigned int> aiEntries;
-    aiEntries.reserve(pcNode->mNumMeshes + 1);
-    for (unsigned int i = 0; i < pcNode->mNumMeshes;++i) {
-        for (unsigned int a = 0; a < avList.size();++a) {
-            if (avList[a].second == pcNode->mMeshes[i]) {
-                aiEntries.push_back(a);
-            }
-        }
-    }
-
-    // now build the new list
-    delete[] pcNode->mMeshes;
-    pcNode->mNumMeshes = (unsigned int)aiEntries.size();
-    pcNode->mMeshes = new unsigned int[pcNode->mNumMeshes];
-
-    for (unsigned int b = 0; b < pcNode->mNumMeshes;++b) {
-        pcNode->mMeshes[b] = aiEntries[b];
-    }
-
-    // recusively update all other nodes
-    for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
-        UpdateNode ( pcNode->mChildren[i], avList );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void SplitLargeMeshesProcess_Triangle::SplitMesh(
-        unsigned int a,
-        aiMesh* pMesh,
-        std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
-    if (pMesh->mNumFaces > SplitLargeMeshesProcess_Triangle::LIMIT) {
-        ASSIMP_LOG_INFO("Mesh exceeds the triangle limit. It will be split ...");
-
-        // we need to split this mesh into sub meshes
-        // determine the size of a submesh
-        const unsigned int iSubMeshes = (pMesh->mNumFaces / LIMIT) + 1;
-
-        const unsigned int iOutFaceNum = pMesh->mNumFaces / iSubMeshes;
-        const unsigned int iOutVertexNum = iOutFaceNum * 3;
-
-        // now generate all submeshes
-        for (unsigned int i = 0; i < iSubMeshes;++i) {
-            aiMesh* pcMesh          = new aiMesh;
-            pcMesh->mNumFaces       = iOutFaceNum;
-            pcMesh->mMaterialIndex  = pMesh->mMaterialIndex;
-
-            // the name carries the adjacency information between the meshes
-            pcMesh->mName = pMesh->mName;
-
-            if (i == iSubMeshes-1) {
-                pcMesh->mNumFaces = iOutFaceNum + (
-                    pMesh->mNumFaces - iOutFaceNum * iSubMeshes);
-            }
-            // copy the list of faces
-            pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
-
-            const unsigned int iBase = iOutFaceNum * i;
-
-            // get the total number of indices
-            unsigned int iCnt = 0;
-            for (unsigned int p = iBase; p < pcMesh->mNumFaces + iBase;++p) {
-                iCnt += pMesh->mFaces[p].mNumIndices;
-            }
-            pcMesh->mNumVertices = iCnt;
-
-            // allocate storage
-            if (pMesh->mVertices != nullptr) {
-                pcMesh->mVertices = new aiVector3D[iCnt];
-            }
-
-            if (pMesh->HasNormals()) {
-                pcMesh->mNormals = new aiVector3D[iCnt];
-            }
-
-            if (pMesh->HasTangentsAndBitangents()) {
-                pcMesh->mTangents = new aiVector3D[iCnt];
-                pcMesh->mBitangents = new aiVector3D[iCnt];
-            }
-
-            // texture coordinates
-            for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
-                pcMesh->mNumUVComponents[c] = pMesh->mNumUVComponents[c];
-                if (pMesh->HasTextureCoords( c)) {
-                    pcMesh->mTextureCoords[c] = new aiVector3D[iCnt];
-                }
-            }
-
-            // vertex colors
-            for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
-                if (pMesh->HasVertexColors( c)) {
-                    pcMesh->mColors[c] = new aiColor4D[iCnt];
-                }
-            }
-
-            if (pMesh->HasBones()) {
-                // assume the number of bones won't change in most cases
-                pcMesh->mBones = new aiBone*[pMesh->mNumBones];
-
-                // iterate through all bones of the mesh and find those which
-                // need to be copied to the split mesh
-                std::vector<aiVertexWeight> avTempWeights;
-                for (unsigned int p = 0; p < pcMesh->mNumBones;++p) {
-                    aiBone* const bone = pcMesh->mBones[p];
-                    avTempWeights.clear();
-                    avTempWeights.reserve(bone->mNumWeights / iSubMeshes);
-
-                    for (unsigned int q = 0; q < bone->mNumWeights;++q) {
-                        aiVertexWeight& weight = bone->mWeights[q];
-                        if(weight.mVertexId >= iBase && weight.mVertexId < iBase + iOutVertexNum) {
-                            avTempWeights.push_back(weight);
-                            weight = avTempWeights.back();
-                            weight.mVertexId -= iBase;
-                        }
-                    }
-
-                    if (!avTempWeights.empty()) {
-                        // we'll need this bone. Copy it ...
-                        aiBone* pc = new aiBone();
-                        pcMesh->mBones[pcMesh->mNumBones++] = pc;
-                        pc->mName = aiString(bone->mName);
-                        pc->mNumWeights = (unsigned int)avTempWeights.size();
-                        pc->mOffsetMatrix = bone->mOffsetMatrix;
-
-                        // no need to reallocate the array for the last submesh.
-                        // Here we can reuse the (large) source array, although
-                        // we'll waste some memory
-                        if (iSubMeshes-1 == i) {
-                            pc->mWeights = bone->mWeights;
-                            bone->mWeights = nullptr;
-                        } else {
-                            pc->mWeights = new aiVertexWeight[pc->mNumWeights];
-                        }
-
-                        // copy the weights
-                        ::memcpy(pc->mWeights,&avTempWeights[0],sizeof(aiVertexWeight)*pc->mNumWeights);
-                    }
-                }
-            }
-
-            // (we will also need to copy the array of indices)
-            unsigned int iCurrent = 0;
-            for (unsigned int p = 0; p < pcMesh->mNumFaces;++p) {
-                pcMesh->mFaces[p].mNumIndices = 3;
-                // allocate a new array
-                const unsigned int iTemp = p + iBase;
-                const unsigned int iNumIndices = pMesh->mFaces[iTemp].mNumIndices;
-
-                // setup face type and number of indices
-                pcMesh->mFaces[p].mNumIndices = iNumIndices;
-                unsigned int* pi = pMesh->mFaces[iTemp].mIndices;
-                unsigned int* piOut = pcMesh->mFaces[p].mIndices = new unsigned int[iNumIndices];
-
-                // need to update the output primitive types
-                switch (iNumIndices) {
-                case 1:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
-                case 2:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
-                case 3:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
-                default:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-                }
-
-                // and copy the contents of the old array, offset by current base
-                for (unsigned int v = 0; v < iNumIndices;++v) {
-                    unsigned int iIndex = pi[v];
-                    unsigned int iIndexOut = iCurrent++;
-                    piOut[v] = iIndexOut;
-
-                    // copy positions
-                    if (pMesh->mVertices != nullptr) {
-                        pcMesh->mVertices[iIndexOut] = pMesh->mVertices[iIndex];
-                    }
-
-                    // copy normals
-                    if (pMesh->HasNormals()) {
-                        pcMesh->mNormals[iIndexOut] = pMesh->mNormals[iIndex];
-                    }
-
-                    // copy tangents/bitangents
-                    if (pMesh->HasTangentsAndBitangents()) {
-                        pcMesh->mTangents[iIndexOut] = pMesh->mTangents[iIndex];
-                        pcMesh->mBitangents[iIndexOut] = pMesh->mBitangents[iIndex];
-                    }
-
-                    // texture coordinates
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
-                        if (pMesh->HasTextureCoords( c ) ) {
-                            pcMesh->mTextureCoords[c][iIndexOut] = pMesh->mTextureCoords[c][iIndex];
-                        }
-                    }
-                    // vertex colors
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
-                        if (pMesh->HasVertexColors( c)) {
-                            pcMesh->mColors[c][iIndexOut] = pMesh->mColors[c][iIndex];
-                        }
-                    }
-                }
-            }
-
-            // add the newly created mesh to the list
-            avList.push_back(std::pair<aiMesh*, unsigned int>(pcMesh,a));
-        }
-
-        // now delete the old mesh data
-        delete pMesh;
-    } else {
-        avList.push_back(std::pair<aiMesh*, unsigned int>(pMesh,a));
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Vertex::SplitLargeMeshesProcess_Vertex() {
-    LIMIT = AI_SLM_DEFAULT_MAX_VERTICES;
-}
-
-// ------------------------------------------------------------------------------------------------
-SplitLargeMeshesProcess_Vertex::~SplitLargeMeshesProcess_Vertex() {
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool SplitLargeMeshesProcess_Vertex::IsActive( unsigned int pFlags) const {
-    return (pFlags & aiProcess_SplitLargeMeshes) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene) {
-    if (0xffffffff == this->LIMIT || nullptr == pScene ) {
-        return;
-    }
-
-    ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Vertex begin");
-
-    std::vector<std::pair<aiMesh*, unsigned int> > avList;
-
-    //Check for point cloud first, 
-    //Do not process point cloud, splitMesh works only with faces data
-    for (unsigned int a = 0; a < pScene->mNumMeshes; a++) {
-        if ( pScene->mMeshes[a]->mPrimitiveTypes == aiPrimitiveType_POINT ) {
-            return;
-        }
-    }
-
-    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
-        this->SplitMesh(a, pScene->mMeshes[a], avList);
-    }
-
-    if (avList.size() != pScene->mNumMeshes) {
-        // it seems something has been split. rebuild the mesh list
-        delete[] pScene->mMeshes;
-        pScene->mNumMeshes = (unsigned int)avList.size();
-        pScene->mMeshes = new aiMesh*[avList.size()];
-
-        for (unsigned int i = 0; i < avList.size();++i) {
-            pScene->mMeshes[i] = avList[i].first;
-        }
-
-        // now we need to update all nodes
-        SplitLargeMeshesProcess_Triangle::UpdateNode(pScene->mRootNode,avList);
-        ASSIMP_LOG_INFO("SplitLargeMeshesProcess_Vertex finished. Meshes have been split");
-    } else {
-        ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Vertex finished. There was nothing to do");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup properties
-void SplitLargeMeshesProcess_Vertex::SetupProperties( const Importer* pImp) {
-    this->LIMIT = pImp->GetPropertyInteger(AI_CONFIG_PP_SLM_VERTEX_LIMIT,AI_SLM_DEFAULT_MAX_VERTICES);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void SplitLargeMeshesProcess_Vertex::SplitMesh(
-        unsigned int a,
-        aiMesh* pMesh,
-        std::vector<std::pair<aiMesh*, unsigned int> >& avList) {
-    if (pMesh->mNumVertices > SplitLargeMeshesProcess_Vertex::LIMIT) {
-        typedef std::vector< std::pair<unsigned int,float> > VertexWeightTable;
-
-        // build a per-vertex weight list if necessary
-        VertexWeightTable* avPerVertexWeights = ComputeVertexBoneWeightTable(pMesh);
-
-        // we need to split this mesh into sub meshes
-        // determine the estimated size of a submesh
-        // (this could be too large. Max waste is a single digit percentage)
-        const unsigned int iSubMeshes = (pMesh->mNumVertices / SplitLargeMeshesProcess_Vertex::LIMIT) + 1;
-
-        // create a std::vector<unsigned int> to indicate which vertices
-        // have already been copied
-        std::vector<unsigned int> avWasCopied;
-        avWasCopied.resize(pMesh->mNumVertices,0xFFFFFFFF);
-
-        // try to find a good estimate for the number of output faces
-        // per mesh. Add 12.5% as buffer
-        unsigned int iEstimatedSize = pMesh->mNumFaces / iSubMeshes;
-        iEstimatedSize += iEstimatedSize >> 3;
-
-        // now generate all submeshes
-        unsigned int iBase( 0 );
-        while (true) {
-            const unsigned int iOutVertexNum = SplitLargeMeshesProcess_Vertex::LIMIT;
-            aiMesh* pcMesh          = new aiMesh;
-            pcMesh->mNumVertices    = 0;
-            pcMesh->mMaterialIndex  = pMesh->mMaterialIndex;
-
-            // the name carries the adjacency information between the meshes
-            pcMesh->mName = pMesh->mName;
-
-            typedef std::vector<aiVertexWeight> BoneWeightList;
-            if (pMesh->HasBones()) {
-                pcMesh->mBones = new aiBone*[pMesh->mNumBones];
-                ::memset(pcMesh->mBones,0,sizeof(void*)*pMesh->mNumBones);
-            }
-
-            // clear the temporary helper array
-            if (iBase) {
-                // we can't use memset here we unsigned int needn' be 32 bits
-                for (auto &elem : avWasCopied) {
-                    elem = 0xffffffff;
-                }
-            }
-
-            // output vectors
-            std::vector<aiFace> vFaces;
-
-            // reserve enough storage for most cases
-            if (pMesh->HasPositions()) {
-                pcMesh->mVertices = new aiVector3D[iOutVertexNum];
-            }
-            if (pMesh->HasNormals()) {
-                pcMesh->mNormals = new aiVector3D[iOutVertexNum];
-            }
-            if (pMesh->HasTangentsAndBitangents()) {
-                pcMesh->mTangents = new aiVector3D[iOutVertexNum];
-                pcMesh->mBitangents = new aiVector3D[iOutVertexNum];
-            }
-            for (unsigned int c = 0; pMesh->HasVertexColors(c);++c) {
-                pcMesh->mColors[c] = new aiColor4D[iOutVertexNum];
-            }
-            for (unsigned int c = 0; pMesh->HasTextureCoords(c);++c) {
-                pcMesh->mNumUVComponents[c] = pMesh->mNumUVComponents[c];
-                pcMesh->mTextureCoords[c] = new aiVector3D[iOutVertexNum];
-            }
-            vFaces.reserve(iEstimatedSize);
-
-            // (we will also need to copy the array of indices)
-            while (iBase < pMesh->mNumFaces) {
-                // allocate a new array
-                const unsigned int iNumIndices = pMesh->mFaces[iBase].mNumIndices;
-
-                // doesn't catch degenerates but is quite fast
-                unsigned int iNeed = 0;
-                for (unsigned int v = 0; v < iNumIndices;++v) {
-                    unsigned int iIndex = pMesh->mFaces[iBase].mIndices[v];
-
-                    // check whether we do already have this vertex
-                    if (0xFFFFFFFF == avWasCopied[iIndex]) {
-                        iNeed++;
-                    }
-                }
-                if (pcMesh->mNumVertices + iNeed > iOutVertexNum) {
-                    // don't use this face
-                    break;
-                }
-
-                vFaces.push_back(aiFace());
-                aiFace& rFace = vFaces.back();
-
-                // setup face type and number of indices
-                rFace.mNumIndices = iNumIndices;
-                rFace.mIndices = new unsigned int[iNumIndices];
-
-                // need to update the output primitive types
-                switch (rFace.mNumIndices) {
-                case 1:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_POINT;
-                    break;
-                case 2:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_LINE;
-                    break;
-                case 3:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-                    break;
-                default:
-                    pcMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
-                }
-
-                // and copy the contents of the old array, offset by current base
-                for (unsigned int v = 0; v < iNumIndices;++v) {
-                    unsigned int iIndex = pMesh->mFaces[iBase].mIndices[v];
-
-                    // check whether we do already have this vertex
-                    if (0xFFFFFFFF != avWasCopied[iIndex]) {
-                        rFace.mIndices[v] = avWasCopied[iIndex];
-                        continue;
-                    }
-
-                    // copy positions
-                    pcMesh->mVertices[pcMesh->mNumVertices] = (pMesh->mVertices[iIndex]);
-
-                    // copy normals
-                    if (pMesh->HasNormals()) {
-                        pcMesh->mNormals[pcMesh->mNumVertices] = (pMesh->mNormals[iIndex]);
-                    }
-
-                    // copy tangents/bitangents
-                    if (pMesh->HasTangentsAndBitangents()) {
-                        pcMesh->mTangents[pcMesh->mNumVertices] = (pMesh->mTangents[iIndex]);
-                        pcMesh->mBitangents[pcMesh->mNumVertices] = (pMesh->mBitangents[iIndex]);
-                    }
-
-                    // texture coordinates
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
-                        if (pMesh->HasTextureCoords( c)) {
-                            pcMesh->mTextureCoords[c][pcMesh->mNumVertices] = pMesh->mTextureCoords[c][iIndex];
-                        }
-                    }
-                    // vertex colors
-                    for (unsigned int c = 0;  c < AI_MAX_NUMBER_OF_COLOR_SETS;++c) {
-                        if (pMesh->HasVertexColors( c)) {
-                            pcMesh->mColors[c][pcMesh->mNumVertices] = pMesh->mColors[c][iIndex];
-                        }
-                    }
-                    // check whether we have bone weights assigned to this vertex
-                    rFace.mIndices[v] = pcMesh->mNumVertices;
-                    if (avPerVertexWeights) {
-                        VertexWeightTable& table = avPerVertexWeights[ pcMesh->mNumVertices ];
-                        if( !table.empty() ) {
-                            for (VertexWeightTable::const_iterator iter =  table.begin();
-                                    iter != table.end();++iter) {
-                                // allocate the bone weight array if necessary
-                                BoneWeightList* pcWeightList = (BoneWeightList*)pcMesh->mBones[(*iter).first];
-                                if (nullptr == pcWeightList) {
-                                    pcMesh->mBones[(*iter).first] = (aiBone*)(pcWeightList = new BoneWeightList());
-                                }
-                                pcWeightList->push_back(aiVertexWeight(pcMesh->mNumVertices,(*iter).second));
-                            }
-                        }
-                    }
-
-                    avWasCopied[iIndex] = pcMesh->mNumVertices;
-                    pcMesh->mNumVertices++;
-                }
-                ++iBase;
-                if(pcMesh->mNumVertices == iOutVertexNum) {
-                    // break here. The face is only added if it was complete
-                    break;
-                }
-            }
-
-            // check which bones we'll need to create for this submesh
-            if (pMesh->HasBones()) {
-                aiBone** ppCurrent = pcMesh->mBones;
-                for (unsigned int k = 0; k < pMesh->mNumBones;++k) {
-                    // check whether the bone is existing
-                    BoneWeightList* pcWeightList;
-                    if ((pcWeightList = (BoneWeightList*)pcMesh->mBones[k])) {
-                        aiBone* pcOldBone = pMesh->mBones[k];
-                        aiBone* pcOut( nullptr );
-                        *ppCurrent++ = pcOut = new aiBone();
-                        pcOut->mName = aiString(pcOldBone->mName);
-                        pcOut->mOffsetMatrix = pcOldBone->mOffsetMatrix;
-                        pcOut->mNumWeights = (unsigned int)pcWeightList->size();
-                        pcOut->mWeights = new aiVertexWeight[pcOut->mNumWeights];
-
-                        // copy the vertex weights
-                        ::memcpy(pcOut->mWeights,&pcWeightList->operator[](0),
-                            pcOut->mNumWeights * sizeof(aiVertexWeight));
-
-                        // delete the temporary bone weight list
-                        delete pcWeightList;
-                        pcMesh->mNumBones++;
-                    }
-                }
-            }
-
-            // copy the face list to the mesh
-            pcMesh->mFaces = new aiFace[vFaces.size()];
-            pcMesh->mNumFaces = (unsigned int)vFaces.size();
-
-            for (unsigned int p = 0; p < pcMesh->mNumFaces;++p) {
-                pcMesh->mFaces[p] = vFaces[p];
-            }
-
-            // add the newly created mesh to the list
-            avList.push_back(std::pair<aiMesh*, unsigned int>(pcMesh,a));
-
-            if (iBase == pMesh->mNumFaces) {
-                // have all faces ... finish the outer loop, too
-                break;
-            }
-        }
-
-        // delete the per-vertex weight list again
-        delete[] avPerVertexWeights;
-
-        // now delete the old mesh data
-        delete pMesh;
-        return;
-    }
-    avList.push_back(std::pair<aiMesh*, unsigned int>(pMesh,a));
-}
diff --git a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h b/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h
deleted file mode 100644
index 3f90576ea9..0000000000
--- a/thirdparty/assimp/code/PostProcessing/SplitLargeMeshes.h
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to split large meshes into sub-meshes
- */
-#ifndef AI_SPLITLARGEMESHES_H_INC
-#define AI_SPLITLARGEMESHES_H_INC
-
-#include <vector>
-#include "Common/BaseProcess.h"
-
-#include <assimp/mesh.h>
-#include <assimp/scene.h>
-
-// Forward declarations
-class SplitLargeMeshesTest;
-
-namespace Assimp {
-
-class SplitLargeMeshesProcess_Triangle;
-class SplitLargeMeshesProcess_Vertex;
-
-// NOTE: If you change these limits, don't forget to change the
-// corresponding values in all Assimp ports
-
-// **********************************************************
-// Java: ConfigProperty.java,
-//  ConfigProperty.DEFAULT_VERTEX_SPLIT_LIMIT
-//  ConfigProperty.DEFAULT_TRIANGLE_SPLIT_LIMIT
-// **********************************************************
-
-// default limit for vertices
-#if (!defined AI_SLM_DEFAULT_MAX_VERTICES)
-#   define AI_SLM_DEFAULT_MAX_VERTICES      1000000
-#endif
-
-// default limit for triangles
-#if (!defined AI_SLM_DEFAULT_MAX_TRIANGLES)
-#   define AI_SLM_DEFAULT_MAX_TRIANGLES     1000000
-#endif
-
-// ---------------------------------------------------------------------------
-/** Post-processing filter to split large meshes into sub-meshes
- *
- * Applied BEFORE the JoinVertices-Step occurs.
- * Returns NON-UNIQUE vertices, splits by triangle number.
-*/
-class ASSIMP_API SplitLargeMeshesProcess_Triangle : public BaseProcess
-{
-    friend class SplitLargeMeshesProcess_Vertex;
-
-public:
-
-    SplitLargeMeshesProcess_Triangle();
-    ~SplitLargeMeshesProcess_Triangle();
-
-public:
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag.
-    * @param pFlags The processing flags the importer was called with. A
-    *   bitwise combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields,
-    *   false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    virtual void SetupProperties(const Importer* pImp);
-
-
-    //! Set the split limit - needed for unit testing
-    inline void SetLimit(unsigned int l)
-        {LIMIT = l;}
-
-    //! Get the split limit
-    inline unsigned int GetLimit() const
-        {return LIMIT;}
-
-public:
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    //! Apply the algorithm to a given mesh
-    void SplitMesh (unsigned int a, aiMesh* pcMesh,
-        std::vector<std::pair<aiMesh*, unsigned int> >& avList);
-
-    // -------------------------------------------------------------------
-    //! Update a node in the asset after a few of its meshes
-    //! have been split
-    static void UpdateNode(aiNode* pcNode,
-        const std::vector<std::pair<aiMesh*, unsigned int> >& avList);
-
-public:
-    //! Triangle limit
-    unsigned int LIMIT;
-};
-
-
-// ---------------------------------------------------------------------------
-/** Post-processing filter to split large meshes into sub-meshes
- *
- * Applied AFTER the JoinVertices-Step occurs.
- * Returns UNIQUE vertices, splits by vertex number.
-*/
-class ASSIMP_API SplitLargeMeshesProcess_Vertex : public BaseProcess
-{
-public:
-
-    SplitLargeMeshesProcess_Vertex();
-    ~SplitLargeMeshesProcess_Vertex();
-
-public:
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-    * @param pFlags The processing flags the importer was called with. A bitwise
-    *   combination of #aiPostProcessSteps.
-    * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Called prior to ExecuteOnScene().
-    * The function is a request to the process to update its configuration
-    * basing on the Importer's configuration property list.
-    */
-    virtual void SetupProperties(const Importer* pImp);
-
-
-    //! Set the split limit - needed for unit testing
-    inline void SetLimit(unsigned int l)
-        {LIMIT = l;}
-
-    //! Get the split limit
-    inline unsigned int GetLimit() const
-        {return LIMIT;}
-
-public:
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    //! Apply the algorithm to a given mesh
-    void SplitMesh (unsigned int a, aiMesh* pcMesh,
-        std::vector<std::pair<aiMesh*, unsigned int> >& avList);
-
-    // NOTE: Reuse SplitLargeMeshesProcess_Triangle::UpdateNode()
-
-public:
-    //! Triangle limit
-    unsigned int LIMIT;
-};
-
-} // end of namespace Assimp
-
-#endif // !!AI_SPLITLARGEMESHES_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp b/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp
deleted file mode 100644
index 8ae2ba7218..0000000000
--- a/thirdparty/assimp/code/PostProcessing/TextureTransform.cpp
+++ /dev/null
@@ -1,566 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file A helper class that processes texture transformations */
-
-
-
-#include <assimp/Importer.hpp>
-#include <assimp/postprocess.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
-
-#include "TextureTransform.h"
-#include <assimp/StringUtils.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-TextureTransformStep::TextureTransformStep() :
-    configFlags()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-TextureTransformStep::~TextureTransformStep()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool TextureTransformStep::IsActive( unsigned int pFlags) const
-{
-    return  (pFlags & aiProcess_TransformUVCoords) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup properties
-void TextureTransformStep::SetupProperties(const Importer* pImp)
-{
-    configFlags = pImp->GetPropertyInteger(AI_CONFIG_PP_TUV_EVALUATE,AI_UVTRAFO_ALL);
-}
-
-// ------------------------------------------------------------------------------------------------
-void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
-{
-    /*  This function tries to simplify the input UV transformation.
-     *  That's very important as it allows us to reduce the number
-     *  of output UV channels. The order in which the transformations
-     *  are applied is - as always - scaling, rotation, translation.
-     */
-
-    char szTemp[512];
-    int rounded = 0;
-
-
-    /* Optimize the rotation angle. That's slightly difficult as
-     * we have an inprecise floating-point number (when comparing
-     * UV transformations we'll take that into account by using
-     * an epsilon of 5 degrees). If there is a rotation value, we can't
-     * perform any further optimizations.
-     */
-    if (info.mRotation)
-    {
-        float out = info.mRotation;
-        if ((rounded = static_cast<int>((info.mRotation / static_cast<float>(AI_MATH_TWO_PI)))))
-        {
-            out -= rounded * static_cast<float>(AI_MATH_PI);
-            ASSIMP_LOG_INFO_F("Texture coordinate rotation ", info.mRotation, " can be simplified to ", out);
-        }
-
-        // Next step - convert negative rotation angles to positives
-        if (out < 0.f)
-            out = (float)AI_MATH_TWO_PI * 2 + out;
-
-        info.mRotation = out;
-        return;
-    }
-
-
-    /* Optimize UV translation in the U direction. To determine whether
-     * or not we can optimize we need to look at the requested mapping
-     * type (e.g. if mirroring is active there IS a difference between
-     * offset 2 and 3)
-     */
-    if ((rounded  = (int)info.mTranslation.x))  {
-        float out = 0.0f;
-        szTemp[0] = 0;
-        if (aiTextureMapMode_Wrap == info.mapU) {
-            // Wrap - simple take the fraction of the field
-            out = info.mTranslation.x-(float)rounded;
-			ai_snprintf(szTemp, 512, "[w] UV U offset %f can be simplified to %f", info.mTranslation.x, out);
-        }
-        else if (aiTextureMapMode_Mirror == info.mapU && 1 != rounded)  {
-            // Mirror
-            if (rounded % 2)
-                rounded--;
-            out = info.mTranslation.x-(float)rounded;
-
-            ai_snprintf(szTemp,512,"[m/d] UV U offset %f can be simplified to %f",info.mTranslation.x,out);
-        }
-        else if (aiTextureMapMode_Clamp == info.mapU || aiTextureMapMode_Decal == info.mapU)    {
-            // Clamp - translations beyond 1,1 are senseless
-            ai_snprintf(szTemp,512,"[c] UV U offset %f can be clamped to 1.0f",info.mTranslation.x);
-
-            out = 1.f;
-        }
-        if (szTemp[0])      {
-            ASSIMP_LOG_INFO(szTemp);
-            info.mTranslation.x = out;
-        }
-    }
-
-    /* Optimize UV translation in the V direction. To determine whether
-     * or not we can optimize we need to look at the requested mapping
-     * type (e.g. if mirroring is active there IS a difference between
-     * offset 2 and 3)
-     */
-    if ((rounded  = (int)info.mTranslation.y))  {
-        float out = 0.0f;
-        szTemp[0] = 0;
-        if (aiTextureMapMode_Wrap == info.mapV) {
-            // Wrap - simple take the fraction of the field
-            out = info.mTranslation.y-(float)rounded;
-            ::ai_snprintf(szTemp,512,"[w] UV V offset %f can be simplified to %f",info.mTranslation.y,out);
-        }
-        else if (aiTextureMapMode_Mirror == info.mapV  && 1 != rounded) {
-            // Mirror
-            if (rounded % 2)
-                rounded--;
-            out = info.mTranslation.x-(float)rounded;
-
-            ::ai_snprintf(szTemp,512,"[m/d] UV V offset %f can be simplified to %f",info.mTranslation.y,out);
-        }
-        else if (aiTextureMapMode_Clamp == info.mapV || aiTextureMapMode_Decal == info.mapV)    {
-            // Clamp - translations beyond 1,1 are senseless
-            ::ai_snprintf(szTemp,512,"[c] UV V offset %f canbe clamped to 1.0f",info.mTranslation.y);
-
-            out = 1.f;
-        }
-        if (szTemp[0])  {
-            ASSIMP_LOG_INFO(szTemp);
-            info.mTranslation.y = out;
-        }
-    }
-    return;
-}
-
-// ------------------------------------------------------------------------------------------------
-void UpdateUVIndex(const std::list<TTUpdateInfo>& l, unsigned int n)
-{
-    // Don't set if == 0 && wasn't set before
-    for (std::list<TTUpdateInfo>::const_iterator it = l.begin();it != l.end(); ++it) {
-        const TTUpdateInfo& info = *it;
-
-        if (info.directShortcut)
-            *info.directShortcut = n;
-        else if (!n)
-        {
-            info.mat->AddProperty<int>((int*)&n,1,AI_MATKEY_UVWSRC(info.semantic,info.index));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-inline const char* MappingModeToChar(aiTextureMapMode map)
-{
-    if (aiTextureMapMode_Wrap == map)
-        return "-w";
-
-    if (aiTextureMapMode_Mirror == map)
-        return "-m";
-
-    return "-c";
-}
-
-// ------------------------------------------------------------------------------------------------
-void TextureTransformStep::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("TransformUVCoordsProcess begin");
-
-
-    /*  We build a per-mesh list of texture transformations we'll need
-     *  to apply. To achieve this, we iterate through all materials,
-     *  find all textures and get their transformations and UV indices.
-     *  Then we search for all meshes using this material.
-     */
-    typedef std::list<STransformVecInfo> MeshTrafoList;
-    std::vector<MeshTrafoList> meshLists(pScene->mNumMeshes);
-
-    for (unsigned int i = 0; i < pScene->mNumMaterials;++i) {
-
-        aiMaterial* mat = pScene->mMaterials[i];
-        for (unsigned int a = 0; a < mat->mNumProperties;++a)   {
-
-            aiMaterialProperty* prop = mat->mProperties[a];
-            if (!::strcmp( prop->mKey.data, "$tex.file"))   {
-                STransformVecInfo info;
-
-                // Setup a shortcut structure to allow for a fast updating
-                // of the UV index later
-                TTUpdateInfo update;
-                update.mat = (aiMaterial*) mat;
-                update.semantic = prop->mSemantic;
-                update.index = prop->mIndex;
-
-                // Get textured properties and transform
-                for (unsigned int a2 = 0; a2 < mat->mNumProperties;++a2)  {
-                    aiMaterialProperty* prop2 = mat->mProperties[a2];
-                    if (prop2->mSemantic != prop->mSemantic || prop2->mIndex != prop->mIndex) {
-                        continue;
-                    }
-
-                    if ( !::strcmp( prop2->mKey.data, "$tex.uvwsrc")) {
-                        info.uvIndex = *((int*)prop2->mData);
-
-                        // Store a direct pointer for later use
-                        update.directShortcut = (unsigned int*) prop2->mData;
-                    }
-
-                    else if ( !::strcmp( prop2->mKey.data, "$tex.mapmodeu")) {
-                        info.mapU = *((aiTextureMapMode*)prop2->mData);
-                    }
-                    else if ( !::strcmp( prop2->mKey.data, "$tex.mapmodev")) {
-                        info.mapV = *((aiTextureMapMode*)prop2->mData);
-                    }
-                    else if ( !::strcmp( prop2->mKey.data, "$tex.uvtrafo"))  {
-                        // ValidateDS should check this
-                        ai_assert(prop2->mDataLength >= 20);
-                        ::memcpy(&info.mTranslation.x,prop2->mData,sizeof(float)*5);
-
-                        // Directly remove this property from the list
-                        mat->mNumProperties--;
-                        for (unsigned int a3 = a2; a3 < mat->mNumProperties;++a3) {
-                            mat->mProperties[a3] = mat->mProperties[a3+1];
-                        }
-
-                        delete prop2;
-
-                        // Warn: could be an underflow, but this does not invoke undefined behaviour
-                        --a2;
-                    }
-                }
-
-                // Find out which transformations are to be evaluated
-                if (!(configFlags & AI_UVTRAFO_ROTATION)) {
-                    info.mRotation = 0.f;
-                }
-                if (!(configFlags & AI_UVTRAFO_SCALING)) {
-                    info.mScaling = aiVector2D(1.f,1.f);
-                }
-                if (!(configFlags & AI_UVTRAFO_TRANSLATION)) {
-                    info.mTranslation = aiVector2D(0.f,0.f);
-                }
-
-                // Do some preprocessing
-                PreProcessUVTransform(info);
-                info.uvIndex = std::min(info.uvIndex,AI_MAX_NUMBER_OF_TEXTURECOORDS -1u);
-
-                // Find out whether this material is used by more than
-                // one mesh. This will make our task much, much more difficult!
-                unsigned int cnt = 0;
-                for (unsigned int n = 0; n < pScene->mNumMeshes;++n)    {
-                    if (pScene->mMeshes[n]->mMaterialIndex == i)
-                        ++cnt;
-                }
-
-                if (!cnt)
-                    continue;
-                else if (1 != cnt)  {
-                    // This material is referenced by more than one mesh!
-                    // So we need to make sure the UV index for the texture
-                    // is identical for each of it ...
-                    info.lockedPos = AI_TT_UV_IDX_LOCK_TBD;
-                }
-
-                // Get all corresponding meshes
-                for (unsigned int n = 0; n < pScene->mNumMeshes;++n)    {
-                    aiMesh* mesh = pScene->mMeshes[n];
-                    if (mesh->mMaterialIndex != i || !mesh->mTextureCoords[0])
-                        continue;
-
-                    unsigned int uv = info.uvIndex;
-                    if (!mesh->mTextureCoords[uv])  {
-                        // If the requested UV index is not available, take the first one instead.
-                        uv = 0;
-                    }
-
-                    if (mesh->mNumUVComponents[info.uvIndex] >= 3){
-                        ASSIMP_LOG_WARN("UV transformations on 3D mapping channels are not supported");
-                        continue;
-                    }
-
-                    MeshTrafoList::iterator it;
-
-                    // Check whether we have this transform setup already
-                    for (it = meshLists[n].begin();it != meshLists[n].end(); ++it)  {
-
-                        if ((*it) == info && (*it).uvIndex == uv)   {
-                            (*it).updateList.push_back(update);
-                            break;
-                        }
-                    }
-
-                    if (it == meshLists[n].end())   {
-                        meshLists[n].push_back(info);
-                        meshLists[n].back().uvIndex = uv;
-                        meshLists[n].back().updateList.push_back(update);
-                    }
-                }
-            }
-        }
-    }
-
-    char buffer[1024]; // should be sufficiently large
-    unsigned int outChannels = 0, inChannels = 0, transformedChannels = 0;
-
-    // Now process all meshes. Important: we don't remove unreferenced UV channels.
-    // This is a job for the RemoveUnreferencedData-Step.
-    for (unsigned int q = 0; q < pScene->mNumMeshes;++q)    {
-
-        aiMesh* mesh = pScene->mMeshes[q];
-        MeshTrafoList& trafo =  meshLists[q];
-
-        inChannels += mesh->GetNumUVChannels();
-
-        if (!mesh->mTextureCoords[0] || trafo.empty() ||  (trafo.size() == 1 && trafo.begin()->IsUntransformed())) {
-            outChannels += mesh->GetNumUVChannels();
-            continue;
-        }
-
-        // Move untransformed UV channels to the first position in the list ....
-        // except if we need a new locked index which should be as small as possible
-        bool veto = false, need = false;
-        unsigned int cnt = 0;
-        unsigned int untransformed = 0;
-
-        MeshTrafoList::iterator it,it2;
-        for (it = trafo.begin();it != trafo.end(); ++it,++cnt)  {
-
-            if (!(*it).IsUntransformed()) {
-                need = true;
-            }
-
-            if ((*it).lockedPos == AI_TT_UV_IDX_LOCK_TBD)   {
-                // Lock this index and make sure it won't be changed
-                (*it).lockedPos = cnt;
-                veto = true;
-                continue;
-            }
-
-            if (!veto && it != trafo.begin() && (*it).IsUntransformed())    {
-                for (it2 = trafo.begin();it2 != it; ++it2) {
-                    if (!(*it2).IsUntransformed())
-                        break;
-                }
-                trafo.insert(it2,*it);
-                trafo.erase(it);
-                break;
-            }
-        }
-        if (!need)
-            continue;
-
-        // Find all that are not at their 'locked' position and move them to it.
-        // Conflicts are possible but quite unlikely.
-        cnt = 0;
-        for (it = trafo.begin();it != trafo.end(); ++it,++cnt) {
-            if ((*it).lockedPos != AI_TT_UV_IDX_LOCK_NONE && (*it).lockedPos != cnt) {
-                it2 = trafo.begin();unsigned int t = 0;
-                while (t != (*it).lockedPos)
-                    ++it2;
-
-                if ((*it2).lockedPos != AI_TT_UV_IDX_LOCK_NONE) {
-                    ASSIMP_LOG_ERROR("Channel mismatch, can't compute all transformations properly [design bug]");
-                    continue;
-                }
-
-                std::swap(*it2,*it);
-                if ((*it).lockedPos == untransformed)
-                    untransformed = cnt;
-            }
-        }
-
-        // ... and add dummies for all unreferenced channels
-        // 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] ? true : false);
-
-        for (it = trafo.begin();it != trafo.end(); ++it)
-            ref[(*it).uvIndex] = true;
-
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n) {
-            if (ref[n])
-                continue;
-            trafo.push_back(STransformVecInfo());
-            trafo.back().uvIndex = n;
-        }
-
-        // Then check whether this list breaks the channel limit.
-        // The unimportant ones are at the end of the list, so
-        // it shouldn't be too worse if we remove them.
-        unsigned int size = (unsigned int)trafo.size();
-        if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
-
-            if (!DefaultLogger::isNullLogger()) {
-                ASSIMP_LOG_ERROR_F(static_cast<unsigned int>(trafo.size()), " UV channels required but just ", 
-                    AI_MAX_NUMBER_OF_TEXTURECOORDS, " available");
-            }
-            size = AI_MAX_NUMBER_OF_TEXTURECOORDS;
-        }
-
-
-        aiVector3D* old[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-            old[n] = mesh->mTextureCoords[n];
-
-        // Now continue and generate the output channels. Channels
-        // that we're not going to need later can be overridden.
-        it = trafo.begin();
-        for (unsigned int n = 0; n < trafo.size();++n,++it) {
-
-            if (n >= size)  {
-                // Try to use an untransformed channel for all channels we threw over board
-                UpdateUVIndex((*it).updateList,untransformed);
-                continue;
-            }
-
-            outChannels++;
-
-            // Write to the log
-            if (!DefaultLogger::isNullLogger()) {
-                ::ai_snprintf(buffer,1024,"Mesh %u, channel %u: t(%.3f,%.3f), s(%.3f,%.3f), r(%.3f), %s%s",
-                    q,n,
-                    (*it).mTranslation.x,
-                    (*it).mTranslation.y,
-                    (*it).mScaling.x,
-                    (*it).mScaling.y,
-                    AI_RAD_TO_DEG( (*it).mRotation),
-                    MappingModeToChar ((*it).mapU),
-                    MappingModeToChar ((*it).mapV));
-
-                ASSIMP_LOG_INFO(buffer);
-            }
-
-            // Check whether we need a new buffer here
-            if (mesh->mTextureCoords[n])    {
-
-                it2 = it;++it2;
-                for (unsigned int m = n+1; m < size;++m, ++it2) {
-
-                    if ((*it2).uvIndex == n){
-                        it2 = trafo.begin();
-                        break;
-                    }
-                }
-                if (it2 == trafo.begin()){
-                    mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
-                }
-            }
-            else mesh->mTextureCoords[n] = new aiVector3D[mesh->mNumVertices];
-
-            aiVector3D* src = old[(*it).uvIndex];
-            aiVector3D* dest, *end;
-            dest = mesh->mTextureCoords[n];
-
-            ai_assert(NULL != src);
-
-            // Copy the data to the destination array
-            if (dest != src)
-                ::memcpy(dest,src,sizeof(aiVector3D)*mesh->mNumVertices);
-
-            end = dest + mesh->mNumVertices;
-
-            // Build a transformation matrix and transform all UV coords with it
-            if (!(*it).IsUntransformed()) {
-                const aiVector2D& trl = (*it).mTranslation;
-                const aiVector2D& scl = (*it).mScaling;
-
-                // fixme: simplify ..
-                ++transformedChannels;
-                aiMatrix3x3 matrix;
-
-                aiMatrix3x3 m2,m3,m4,m5;
-
-                m4.a1 = scl.x;
-                m4.b2 = scl.y;
-
-                m2.a3 = m2.b3 = 0.5f;
-                m3.a3 = m3.b3 = -0.5f;
-
-                if ((*it).mRotation > AI_TT_ROTATION_EPSILON )
-                    aiMatrix3x3::RotationZ((*it).mRotation,matrix);
-
-                m5.a3 += trl.x; m5.b3 += trl.y;
-                matrix = m2 * m4 * matrix * m3 * m5;
-
-                for (src = dest; src != end; ++src) { /* manual homogenious divide */
-                    src->z = 1.f;
-                    *src = matrix * *src;
-                    src->x /= src->z;
-                    src->y /= src->z;
-                    src->z = 0.f;
-                }
-            }
-
-            // Update all UV indices
-            UpdateUVIndex((*it).updateList,n);
-        }
-    }
-
-    // Print some detailed statistics into the log
-    if (!DefaultLogger::isNullLogger()) {
-
-        if (transformedChannels)    {
-            ASSIMP_LOG_INFO_F("TransformUVCoordsProcess end: ", outChannels, " output channels (in: ", inChannels, ", modified: ", transformedChannels,")");
-        } else {
-            ASSIMP_LOG_DEBUG("TransformUVCoordsProcess finished");
-        }
-    }
-}
-
-
diff --git a/thirdparty/assimp/code/PostProcessing/TextureTransform.h b/thirdparty/assimp/code/PostProcessing/TextureTransform.h
deleted file mode 100644
index 2a5d623d7f..0000000000
--- a/thirdparty/assimp/code/PostProcessing/TextureTransform.h
+++ /dev/null
@@ -1,232 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Definition of a helper step that processes texture transformations */
-#ifndef AI_TEXTURE_TRANSFORM_H_INCLUDED
-#define AI_TEXTURE_TRANSFORM_H_INCLUDED
-
-#include <assimp/BaseImporter.h>
-#include "Common/BaseProcess.h"
-
-#include <assimp/material.h>
-#include <list>
-
-struct aiNode;
-struct aiMaterial;
-
-namespace Assimp    {
-
-#define AI_TT_UV_IDX_LOCK_TBD   0xffffffff
-#define AI_TT_UV_IDX_LOCK_NONE  0xeeeeeeee
-
-
-#define AI_TT_ROTATION_EPSILON  ((float)AI_DEG_TO_RAD(0.5))
-
-// ---------------------------------------------------------------------------
-/** Small helper structure representing a shortcut into the material list
- *  to be able to update some values quickly.
-*/
-struct TTUpdateInfo {
-    TTUpdateInfo() AI_NO_EXCEPT
-    : directShortcut(nullptr)
-    , mat(nullptr)
-    , semantic(0)
-    , index(0) {
-        // empty
-    }
-
-    //! Direct shortcut, if available
-    unsigned int* directShortcut;
-
-    //! Material
-    aiMaterial *mat;
-
-    //! Texture type and index
-    unsigned int semantic, index;
-};
-
-
-// ---------------------------------------------------------------------------
-/** Helper class representing texture coordinate transformations
-*/
-struct STransformVecInfo : public aiUVTransform {
-    STransformVecInfo() AI_NO_EXCEPT
-    : uvIndex(0)
-    , mapU(aiTextureMapMode_Wrap)
-    , mapV(aiTextureMapMode_Wrap)
-    , lockedPos(AI_TT_UV_IDX_LOCK_NONE) {
-        // empty
-    }
-
-    //! Source texture coordinate index
-    unsigned int uvIndex;
-
-    //! Texture mapping mode in the u, v direction
-    aiTextureMapMode mapU,mapV;
-
-    //! Locked destination UV index
-    //! AI_TT_UV_IDX_LOCK_TBD - to be determined
-    //! AI_TT_UV_IDX_LOCK_NONE - none (default)
-    unsigned int lockedPos;
-
-    //! Update info - shortcuts into all materials
-    //! that are referencing this transform setup
-    std::list<TTUpdateInfo> updateList;
-
-
-    // -------------------------------------------------------------------
-    /** Compare two transform setups
-    */
-    inline bool operator== (const STransformVecInfo& other) const
-    {
-        // We use a small epsilon here
-        const static float epsilon = 0.05f;
-
-        if (std::fabs( mTranslation.x - other.mTranslation.x ) > epsilon ||
-            std::fabs( mTranslation.y - other.mTranslation.y ) > epsilon)
-        {
-            return false;
-        }
-
-        if (std::fabs( mScaling.x - other.mScaling.x ) > epsilon ||
-            std::fabs( mScaling.y - other.mScaling.y ) > epsilon)
-        {
-            return false;
-        }
-
-        if (std::fabs( mRotation - other.mRotation) > epsilon)
-        {
-            return false;
-        }
-        return true;
-    }
-
-    inline bool operator!= (const STransformVecInfo& other) const
-    {
-            return !(*this == other);
-    }
-
-
-    // -------------------------------------------------------------------
-    /** Returns whether this is an untransformed texture coordinate set
-    */
-    inline bool IsUntransformed() const
-    {
-        return (1.0f == mScaling.x && 1.f == mScaling.y &&
-            !mTranslation.x && !mTranslation.y &&
-            mRotation < AI_TT_ROTATION_EPSILON);
-    }
-
-    // -------------------------------------------------------------------
-    /** Build a 3x3 matrix from the transformations
-    */
-    inline void GetMatrix(aiMatrix3x3& mOut)
-    {
-        mOut = aiMatrix3x3();
-
-        if (1.0f != mScaling.x || 1.0f != mScaling.y)
-        {
-            aiMatrix3x3 mScale;
-            mScale.a1 = mScaling.x;
-            mScale.b2 = mScaling.y;
-            mOut = mScale;
-        }
-        if (mRotation)
-        {
-            aiMatrix3x3 mRot;
-            mRot.a1 = mRot.b2 = std::cos(mRotation);
-            mRot.a2 = mRot.b1 = std::sin(mRotation);
-            mRot.a2 = -mRot.a2;
-            mOut *= mRot;
-        }
-        if (mTranslation.x || mTranslation.y)
-        {
-            aiMatrix3x3 mTrans;
-            mTrans.a3 = mTranslation.x;
-            mTrans.b3 = mTranslation.y;
-            mOut *= mTrans;
-        }
-    }
-};
-
-
-// ---------------------------------------------------------------------------
-/** Helper step to compute final UV coordinate sets if there are scalings
- *  or rotations in the original data read from the file.
-*/
-class TextureTransformStep : public BaseProcess
-{
-public:
-
-    TextureTransformStep();
-    ~TextureTransformStep();
-
-public:
-
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    void SetupProperties(const Importer* pImp);
-
-
-protected:
-
-
-    // -------------------------------------------------------------------
-    /** Preprocess a specific UV transformation setup
-     *
-     *  @param info Transformation setup to be preprocessed.
-    */
-    void PreProcessUVTransform(STransformVecInfo& info);
-
-private:
-
-    unsigned int configFlags;
-};
-
-}
-
-#endif //! AI_TEXTURE_TRANSFORM_H_INCLUDED
diff --git a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp b/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp
deleted file mode 100644
index 1040836bbe..0000000000
--- a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.cpp
+++ /dev/null
@@ -1,530 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  TriangulateProcess.cpp
- *  @brief Implementation of the post processing step to split up
- *    all faces with more than three indices into triangles.
- *
- *
- *  The triangulation algorithm will handle concave or convex polygons.
- *  Self-intersecting or non-planar polygons are not rejected, but
- *  they're probably not triangulated correctly.
- *
- * DEBUG SWITCHES - do not enable any of them in release builds:
- *
- * AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING
- *   - generates vertex colors to represent the face winding order.
- *     the first vertex of a polygon becomes red, the last blue.
- * AI_BUILD_TRIANGULATE_DEBUG_POLYS
- *   - dump all polygons and their triangulation sequences to
- *     a file
- */
-#ifndef ASSIMP_BUILD_NO_TRIANGULATE_PROCESS
-
-#include "PostProcessing/TriangulateProcess.h"
-#include "PostProcessing/ProcessHelper.h"
-#include "Common/PolyTools.h"
-
-#include <memory>
-
-//#define AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING
-//#define AI_BUILD_TRIANGULATE_DEBUG_POLYS
-
-#define POLY_GRID_Y 40
-#define POLY_GRID_X 70
-#define POLY_GRID_XPAD 20
-#define POLY_OUTPUT_FILE "assimp_polygons_debug.txt"
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-TriangulateProcess::TriangulateProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-TriangulateProcess::~TriangulateProcess()
-{
-    // nothing to do here
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool TriangulateProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_Triangulate) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void TriangulateProcess::Execute( aiScene* pScene)
-{
-    ASSIMP_LOG_DEBUG("TriangulateProcess begin");
-
-    bool bHas = false;
-    for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
-    {
-        if (pScene->mMeshes[ a ]) {
-            if ( TriangulateMesh( pScene->mMeshes[ a ] ) ) {
-                bHas = true;
-            }
-        }
-    }
-    if ( bHas ) {
-        ASSIMP_LOG_INFO( "TriangulateProcess finished. All polygons have been triangulated." );
-    } else {
-        ASSIMP_LOG_DEBUG( "TriangulateProcess finished. There was nothing to be done." );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Triangulates the given mesh.
-bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
-{
-    // Now we have aiMesh::mPrimitiveTypes, so this is only here for test cases
-    if (!pMesh->mPrimitiveTypes)    {
-        bool bNeed = false;
-
-        for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
-            const aiFace& face = pMesh->mFaces[a];
-
-            if( face.mNumIndices != 3)  {
-                bNeed = true;
-            }
-        }
-        if (!bNeed)
-            return false;
-    }
-    else if (!(pMesh->mPrimitiveTypes & aiPrimitiveType_POLYGON)) {
-        return false;
-    }
-
-    // Find out how many output faces we'll get
-    unsigned int numOut = 0, max_out = 0;
-    bool get_normals = true;
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
-        aiFace& face = pMesh->mFaces[a];
-        if (face.mNumIndices <= 4) {
-            get_normals = false;
-        }
-        if( face.mNumIndices <= 3) {
-            numOut++;
-
-        }
-        else {
-            numOut += face.mNumIndices-2;
-            max_out = std::max(max_out,face.mNumIndices);
-        }
-    }
-
-    // Just another check whether aiMesh::mPrimitiveTypes is correct
-    ai_assert(numOut != pMesh->mNumFaces);
-
-    aiVector3D* nor_out = NULL;
-
-    // if we don't have normals yet, but expect them to be a cheap side
-    // product of triangulation anyway, allocate storage for them.
-    if (!pMesh->mNormals && get_normals) {
-        // XXX need a mechanism to inform the GenVertexNormals process to treat these normals as preprocessed per-face normals
-    //  nor_out = pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-    }
-
-    // the output mesh will contain triangles, but no polys anymore
-    pMesh->mPrimitiveTypes |= aiPrimitiveType_TRIANGLE;
-    pMesh->mPrimitiveTypes &= ~aiPrimitiveType_POLYGON;
-
-    aiFace* out = new aiFace[numOut](), *curOut = out;
-    std::vector<aiVector3D> temp_verts3d(max_out+2); /* temporary storage for vertices */
-    std::vector<aiVector2D> temp_verts(max_out+2);
-
-    // Apply vertex colors to represent the face winding?
-#ifdef AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING
-    if (!pMesh->mColors[0])
-        pMesh->mColors[0] = new aiColor4D[pMesh->mNumVertices];
-    else
-        new(pMesh->mColors[0]) aiColor4D[pMesh->mNumVertices];
-
-    aiColor4D* clr = pMesh->mColors[0];
-#endif
-
-#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
-    FILE* fout = fopen(POLY_OUTPUT_FILE,"a");
-#endif
-
-    const aiVector3D* verts = pMesh->mVertices;
-
-    // use std::unique_ptr to avoid slow std::vector<bool> specialiations
-    std::unique_ptr<bool[]> done(new bool[max_out]);
-    for( unsigned int a = 0; a < pMesh->mNumFaces; a++) {
-        aiFace& face = pMesh->mFaces[a];
-
-        unsigned int* idx = face.mIndices;
-        int num = (int)face.mNumIndices, ear = 0, tmp, prev = num-1, next = 0, max = num;
-
-        // Apply vertex colors to represent the face winding?
-#ifdef AI_BUILD_TRIANGULATE_COLOR_FACE_WINDING
-        for (unsigned int i = 0; i < face.mNumIndices; ++i) {
-            aiColor4D& c = clr[idx[i]];
-            c.r = (i+1) / (float)max;
-            c.b = 1.f - c.r;
-        }
-#endif
-
-        aiFace* const last_face = curOut;
-
-        // if it's a simple point,line or triangle: just copy it
-        if( face.mNumIndices <= 3)
-        {
-            aiFace& nface = *curOut++;
-            nface.mNumIndices = face.mNumIndices;
-            nface.mIndices    = face.mIndices;
-
-            face.mIndices = NULL;
-            continue;
-        }
-        // optimized code for quadrilaterals
-        else if ( face.mNumIndices == 4) {
-
-            // quads can have at maximum one concave vertex. Determine
-            // this vertex (if it exists) and start tri-fanning from
-            // it.
-            unsigned int start_vertex = 0;
-            for (unsigned int i = 0; i < 4; ++i) {
-                const aiVector3D& v0 = verts[face.mIndices[(i+3) % 4]];
-                const aiVector3D& v1 = verts[face.mIndices[(i+2) % 4]];
-                const aiVector3D& v2 = verts[face.mIndices[(i+1) % 4]];
-
-                const aiVector3D& v = verts[face.mIndices[i]];
-
-                aiVector3D left = (v0-v);
-                aiVector3D diag = (v1-v);
-                aiVector3D right = (v2-v);
-
-                left.Normalize();
-                diag.Normalize();
-                right.Normalize();
-
-                const float angle = std::acos(left*diag) + std::acos(right*diag);
-                if (angle > AI_MATH_PI_F) {
-                    // this is the concave point
-                    start_vertex = i;
-                    break;
-                }
-            }
-
-            const unsigned int temp[] = {face.mIndices[0], face.mIndices[1], face.mIndices[2], face.mIndices[3]};
-
-            aiFace& nface = *curOut++;
-            nface.mNumIndices = 3;
-            nface.mIndices = face.mIndices;
-
-            nface.mIndices[0] = temp[start_vertex];
-            nface.mIndices[1] = temp[(start_vertex + 1) % 4];
-            nface.mIndices[2] = temp[(start_vertex + 2) % 4];
-
-            aiFace& sface = *curOut++;
-            sface.mNumIndices = 3;
-            sface.mIndices = new unsigned int[3];
-
-            sface.mIndices[0] = temp[start_vertex];
-            sface.mIndices[1] = temp[(start_vertex + 2) % 4];
-            sface.mIndices[2] = temp[(start_vertex + 3) % 4];
-
-            // prevent double deletion of the indices field
-            face.mIndices = NULL;
-            continue;
-        }
-        else
-        {
-            // A polygon with more than 3 vertices can be either concave or convex.
-            // Usually everything we're getting is convex and we could easily
-            // triangulate by tri-fanning. However, LightWave is probably the only
-            // modeling suite to make extensive use of highly concave, monster polygons ...
-            // so we need to apply the full 'ear cutting' algorithm to get it right.
-
-            // RERQUIREMENT: polygon is expected to be simple and *nearly* planar.
-            // We project it onto a plane to get a 2d triangle.
-
-            // Collect all vertices of of the polygon.
-           for (tmp = 0; tmp < max; ++tmp) {
-                temp_verts3d[tmp] = verts[idx[tmp]];
-            }
-
-            // Get newell normal of the polygon. Store it for future use if it's a polygon-only mesh
-            aiVector3D n;
-            NewellNormal<3,3,3>(n,max,&temp_verts3d.front().x,&temp_verts3d.front().y,&temp_verts3d.front().z);
-            if (nor_out) {
-                 for (tmp = 0; tmp < max; ++tmp)
-                     nor_out[idx[tmp]] = n;
-            }
-
-            // Select largest normal coordinate to ignore for projection
-            const float ax = (n.x>0 ? n.x : -n.x);
-            const float ay = (n.y>0 ? n.y : -n.y);
-            const float az = (n.z>0 ? n.z : -n.z);
-
-            unsigned int ac = 0, bc = 1; /* no z coord. projection to xy */
-            float inv = n.z;
-            if (ax > ay) {
-                if (ax > az) { /* no x coord. projection to yz */
-                    ac = 1; bc = 2;
-                    inv = n.x;
-                }
-            }
-            else if (ay > az) { /* no y coord. projection to zy */
-                ac = 2; bc = 0;
-                inv = n.y;
-            }
-
-            // Swap projection axes to take the negated projection vector into account
-            if (inv < 0.f) {
-                std::swap(ac,bc);
-            }
-
-            for (tmp =0; tmp < max; ++tmp) {
-                temp_verts[tmp].x = verts[idx[tmp]][ac];
-                temp_verts[tmp].y = verts[idx[tmp]][bc];
-                done[tmp] = false;
-            }
-
-#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
-            // plot the plane onto which we mapped the polygon to a 2D ASCII pic
-            aiVector2D bmin,bmax;
-            ArrayBounds(&temp_verts[0],max,bmin,bmax);
-
-            char grid[POLY_GRID_Y][POLY_GRID_X+POLY_GRID_XPAD];
-            std::fill_n((char*)grid,POLY_GRID_Y*(POLY_GRID_X+POLY_GRID_XPAD),' ');
-
-            for (int i =0; i < max; ++i) {
-                const aiVector2D& v = (temp_verts[i] - bmin) / (bmax-bmin);
-                const size_t x = static_cast<size_t>(v.x*(POLY_GRID_X-1)), y = static_cast<size_t>(v.y*(POLY_GRID_Y-1));
-                char* loc = grid[y]+x;
-                if (grid[y][x] != ' ') {
-                    for(;*loc != ' '; ++loc);
-                    *loc++ = '_';
-                }
-                *(loc+::ai_snprintf(loc, POLY_GRID_XPAD,"%i",i)) = ' ';
-            }
-
-
-            for(size_t y = 0; y < POLY_GRID_Y; ++y) {
-                grid[y][POLY_GRID_X+POLY_GRID_XPAD-1] = '\0';
-                fprintf(fout,"%s\n",grid[y]);
-            }
-
-            fprintf(fout,"\ntriangulation sequence: ");
-#endif
-
-            //
-            // FIXME: currently this is the slow O(kn) variant with a worst case
-            // complexity of O(n^2) (I think). Can be done in O(n).
-            while (num > 3) {
-
-                // Find the next ear of the polygon
-                int num_found = 0;
-                for (ear = next;;prev = ear,ear = next) {
-
-                    // break after we looped two times without a positive match
-                    for (next=ear+1;done[(next>=max?next=0:next)];++next);
-                    if (next < ear) {
-                        if (++num_found == 2) {
-                            break;
-                        }
-                    }
-                    const aiVector2D* pnt1 = &temp_verts[ear],
-                        *pnt0 = &temp_verts[prev],
-                        *pnt2 = &temp_verts[next];
-
-                    // Must be a convex point. Assuming ccw winding, it must be on the right of the line between p-1 and p+1.
-                    if (OnLeftSideOfLine2D(*pnt0,*pnt2,*pnt1)) {
-                        continue;
-                    }
-
-                    // and no other point may be contained in this triangle
-                    for ( tmp = 0; tmp < max; ++tmp) {
-
-                        // We need to compare the actual values because it's possible that multiple indexes in
-                        // the polygon are referring to the same position. concave_polygon.obj is a sample
-                        //
-                        // FIXME: Use 'epsiloned' comparisons instead? Due to numeric inaccuracies in
-                        // PointInTriangle() I'm guessing that it's actually possible to construct
-                        // input data that would cause us to end up with no ears. The problem is,
-                        // which epsilon? If we chose a too large value, we'd get wrong results
-                        const aiVector2D& vtmp = temp_verts[tmp];
-                        if ( vtmp != *pnt1 && vtmp != *pnt2 && vtmp != *pnt0 && PointInTriangle2D(*pnt0,*pnt1,*pnt2,vtmp)) {
-                            break;
-                        }
-                    }
-                    if (tmp != max) {
-                        continue;
-                    }
-
-                    // this vertex is an ear
-                    break;
-                }
-                if (num_found == 2) {
-
-                    // Due to the 'two ear theorem', every simple polygon with more than three points must
-                    // have 2 'ears'. Here's definitely something wrong ... but we don't give up yet.
-                    //
-
-                    // Instead we're continuing with the standard tri-fanning algorithm which we'd
-                    // use if we had only convex polygons. That's life.
-                    ASSIMP_LOG_ERROR("Failed to triangulate polygon (no ear found). Probably not a simple polygon?");
-
-#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
-                    fprintf(fout,"critical error here, no ear found! ");
-#endif
-                    num = 0;
-                    break;
-
-                    curOut -= (max-num); /* undo all previous work */
-                    for (tmp = 0; tmp < max-2; ++tmp) {
-                        aiFace& nface = *curOut++;
-
-                        nface.mNumIndices = 3;
-                        if (!nface.mIndices)
-                            nface.mIndices = new unsigned int[3];
-
-                        nface.mIndices[0] = 0;
-                        nface.mIndices[1] = tmp+1;
-                        nface.mIndices[2] = tmp+2;
-
-                    }
-                    num = 0;
-                    break;
-                }
-
-                aiFace& nface = *curOut++;
-                nface.mNumIndices = 3;
-
-                if (!nface.mIndices) {
-                    nface.mIndices = new unsigned int[3];
-                }
-
-                // setup indices for the new triangle ...
-                nface.mIndices[0] = prev;
-                nface.mIndices[1] = ear;
-                nface.mIndices[2] = next;
-
-                // exclude the ear from most further processing
-                done[ear] = true;
-                --num;
-            }
-            if (num > 0) {
-                // We have three indices forming the last 'ear' remaining. Collect them.
-                aiFace& nface = *curOut++;
-                nface.mNumIndices = 3;
-                if (!nface.mIndices) {
-                    nface.mIndices = new unsigned int[3];
-                }
-
-                for (tmp = 0; done[tmp]; ++tmp);
-                nface.mIndices[0] = tmp;
-
-                for (++tmp; done[tmp]; ++tmp);
-                nface.mIndices[1] = tmp;
-
-                for (++tmp; done[tmp]; ++tmp);
-                nface.mIndices[2] = tmp;
-
-            }
-        }
-
-#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
-
-        for(aiFace* f = last_face; f != curOut; ++f) {
-            unsigned int* i = f->mIndices;
-            fprintf(fout," (%i %i %i)",i[0],i[1],i[2]);
-        }
-
-        fprintf(fout,"\n*********************************************************************\n");
-        fflush(fout);
-
-#endif
-
-        for(aiFace* f = last_face; f != curOut; ) {
-            unsigned int* i = f->mIndices;
-
-            //  drop dumb 0-area triangles - deactivated for now:
-            //FindDegenerates post processing step can do the same thing
-            //if (std::fabs(GetArea2D(temp_verts[i[0]],temp_verts[i[1]],temp_verts[i[2]])) < 1e-5f) {
-            //    ASSIMP_LOG_DEBUG("Dropping triangle with area 0");
-            //    --curOut;
-
-            //    delete[] f->mIndices;
-            //    f->mIndices = nullptr;
-
-            //    for(aiFace* ff = f; ff != curOut; ++ff) {
-            //        ff->mNumIndices = (ff+1)->mNumIndices;
-            //        ff->mIndices = (ff+1)->mIndices;
-            //        (ff+1)->mIndices = nullptr;
-            //    }
-            //    continue;
-            //}
-
-            i[0] = idx[i[0]];
-            i[1] = idx[i[1]];
-            i[2] = idx[i[2]];
-            ++f;
-        }
-
-        delete[] face.mIndices;
-        face.mIndices = NULL;
-    }
-
-#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
-    fclose(fout);
-#endif
-
-    // kill the old faces
-    delete [] pMesh->mFaces;
-
-    // ... and store the new ones
-    pMesh->mFaces    = out;
-    pMesh->mNumFaces = (unsigned int)(curOut-out); /* not necessarily equal to numOut */
-    return true;
-}
-
-#endif // !! ASSIMP_BUILD_NO_TRIANGULATE_PROCESS
diff --git a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h b/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h
deleted file mode 100644
index 916b5103dd..0000000000
--- a/thirdparty/assimp/code/PostProcessing/TriangulateProcess.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a post processing step to triangulate all faces
-          with more than three vertices.
- */
-#ifndef AI_TRIANGULATEPROCESS_H_INC
-#define AI_TRIANGULATEPROCESS_H_INC
-
-#include "Common/BaseProcess.h"
-
-struct aiMesh;
-
-class TriangulateProcessTest;
-
-namespace Assimp {
-
-// ---------------------------------------------------------------------------
-/** The TriangulateProcess splits up all faces with more than three indices
- * into triangles. You usually want this to happen because the graphics cards
- * need their data as triangles.
- */
-class ASSIMP_API TriangulateProcess : public BaseProcess {
-public:
-    TriangulateProcess();
-    ~TriangulateProcess();
-
-    // -------------------------------------------------------------------
-    /** Returns whether the processing step is present in the given flag field.
-     * @param pFlags The processing flags the importer was called with. A bitwise
-     *   combination of #aiPostProcessSteps.
-     * @return true if the process is present in this flag fields, false if not.
-    */
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    /** Executes the post processing step on the given imported data.
-    * At the moment a process is not supposed to fail.
-    * @param pScene The imported data to work at.
-    */
-    void Execute( aiScene* pScene);
-
-    // -------------------------------------------------------------------
-    /** Triangulates the given mesh.
-     * @param pMesh The mesh to triangulate.
-     */
-    bool TriangulateMesh( aiMesh* pMesh);
-};
-
-} // end of namespace Assimp
-
-#endif // AI_TRIANGULATEPROCESS_H_INC
diff --git a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp b/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp
deleted file mode 100644
index 75d1b6ef78..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.cpp
+++ /dev/null
@@ -1,1034 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
----------------------------------------------------------------------------
-*/
-
-/** @file  ValidateDataStructure.cpp
- *  @brief Implementation of the post processing step to validate
- *    the data structure returned by Assimp.
- */
-
-// internal headers
-#include "ValidateDataStructure.h"
-#include <assimp/BaseImporter.h>
-#include <assimp/fast_atof.h>
-#include "ProcessHelper.h"
-#include <memory>
-
-// CRT headers
-#include <stdarg.h>
-
-using namespace Assimp;
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-ValidateDSProcess::ValidateDSProcess() :
-    mScene()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-ValidateDSProcess::~ValidateDSProcess()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the processing step is present in the given flag field.
-bool ValidateDSProcess::IsActive( unsigned int pFlags) const
-{
-    return (pFlags & aiProcess_ValidateDataStructure) != 0;
-}
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void ValidateDSProcess::ReportError(const char* msg,...)
-{
-    ai_assert(NULL != msg);
-
-    va_list args;
-    va_start(args,msg);
-
-    char szBuffer[3000];
-    const int iLen = vsprintf(szBuffer,msg,args);
-    ai_assert(iLen > 0);
-
-    va_end(args);
-
-    throw DeadlyImportError("Validation failed: " + std::string(szBuffer,iLen));
-}
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::ReportWarning(const char* msg,...)
-{
-    ai_assert(NULL != msg);
-
-    va_list args;
-    va_start(args,msg);
-
-    char szBuffer[3000];
-    const int iLen = vsprintf(szBuffer,msg,args);
-    ai_assert(iLen > 0);
-
-    va_end(args);
-    ASSIMP_LOG_WARN("Validation warning: " + std::string(szBuffer,iLen));
-}
-
-// ------------------------------------------------------------------------------------------------
-inline
-int HasNameMatch(const aiString& in, aiNode* node) {
-    int result = (node->mName == in ? 1 : 0 );
-    for (unsigned int i = 0; i < node->mNumChildren;++i)    {
-        result += HasNameMatch(in,node->mChildren[i]);
-    }
-    return result;
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-inline
-void ValidateDSProcess::DoValidation(T** parray, unsigned int size, const char* firstName, const char* secondName) {
-    // validate all entries
-    if (size)
-    {
-        if (!parray)
-        {
-            ReportError("aiScene::%s is NULL (aiScene::%s is %i)",
-                firstName, secondName, size);
-        }
-        for (unsigned int i = 0; i < size;++i)
-        {
-            if (!parray[i])
-            {
-                ReportError("aiScene::%s[%i] is NULL (aiScene::%s is %i)",
-                    firstName,i,secondName,size);
-            }
-            Validate(parray[i]);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-inline void ValidateDSProcess::DoValidationEx(T** parray, unsigned int size,
-    const char* firstName, const char* secondName)
-{
-    // validate all entries
-    if (size)
-    {
-        if (!parray)    {
-            ReportError("aiScene::%s is NULL (aiScene::%s is %i)",
-                firstName, secondName, size);
-        }
-        for (unsigned int i = 0; i < size;++i)
-        {
-            if (!parray[i])
-            {
-                ReportError("aiScene::%s[%u] is NULL (aiScene::%s is %u)",
-                    firstName,i,secondName,size);
-            }
-            Validate(parray[i]);
-
-            // check whether there are duplicate names
-            for (unsigned int a = i+1; a < size;++a)
-            {
-                if (parray[i]->mName == parray[a]->mName)
-                {
-                	ReportError("aiScene::%s[%u] has the same name as "
-                        "aiScene::%s[%u]",firstName, i,secondName, a);
-                }
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-inline
-void ValidateDSProcess::DoValidationWithNameCheck(T** array, unsigned int size, const char* firstName,
-        const char* secondName) {
-    // validate all entries
-    DoValidationEx(array,size,firstName,secondName);
-
-    for (unsigned int i = 0; i < size;++i) {
-        int res = HasNameMatch(array[i]->mName,mScene->mRootNode);
-        if (0 == res)   {
-            const std::string name = static_cast<char*>(array[i]->mName.data);
-            ReportError("aiScene::%s[%i] has no corresponding node in the scene graph (%s)",
-                firstName,i, name.c_str());
-        } else if (1 != res)  {
-            const std::string name = static_cast<char*>(array[i]->mName.data);
-            ReportError("aiScene::%s[%i]: there are more than one nodes with %s as name",
-                firstName,i, name.c_str());
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Executes the post processing step on the given imported data.
-void ValidateDSProcess::Execute( aiScene* pScene) {
-    mScene = pScene;
-    ASSIMP_LOG_DEBUG("ValidateDataStructureProcess begin");
-
-    // validate the node graph of the scene
-    Validate(pScene->mRootNode);
-
-    // validate all meshes
-    if (pScene->mNumMeshes) {
-        DoValidation(pScene->mMeshes,pScene->mNumMeshes,"mMeshes","mNumMeshes");
-    }
-    else if (!(mScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) {
-        ReportError("aiScene::mNumMeshes is 0. At least one mesh must be there");
-    }
-    else if (pScene->mMeshes)   {
-        ReportError("aiScene::mMeshes is non-null although there are no meshes");
-    }
-
-    // validate all animations
-    if (pScene->mNumAnimations) {
-        DoValidation(pScene->mAnimations,pScene->mNumAnimations,
-            "mAnimations","mNumAnimations");
-    }
-    else if (pScene->mAnimations)   {
-        ReportError("aiScene::mAnimations is non-null although there are no animations");
-    }
-
-    // validate all cameras
-    if (pScene->mNumCameras) {
-        DoValidationWithNameCheck(pScene->mCameras,pScene->mNumCameras,
-            "mCameras","mNumCameras");
-    }
-    else if (pScene->mCameras)  {
-        ReportError("aiScene::mCameras is non-null although there are no cameras");
-    }
-
-    // validate all lights
-    if (pScene->mNumLights) {
-        DoValidationWithNameCheck(pScene->mLights,pScene->mNumLights,
-            "mLights","mNumLights");
-    }
-    else if (pScene->mLights)   {
-        ReportError("aiScene::mLights is non-null although there are no lights");
-    }
-
-    // validate all textures
-    if (pScene->mNumTextures) {
-        DoValidation(pScene->mTextures,pScene->mNumTextures,
-            "mTextures","mNumTextures");
-    }
-    else if (pScene->mTextures) {
-        ReportError("aiScene::mTextures is non-null although there are no textures");
-    }
-
-    // validate all materials
-    if (pScene->mNumMaterials) {
-        DoValidation(pScene->mMaterials,pScene->mNumMaterials,"mMaterials","mNumMaterials");
-    }
-#if 0
-    // NOTE: ScenePreprocessor generates a default material if none is there
-    else if (!(mScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) {
-        ReportError("aiScene::mNumMaterials is 0. At least one material must be there");
-    }
-#endif
-    else if (pScene->mMaterials)    {
-        ReportError("aiScene::mMaterials is non-null although there are no materials");
-    }
-
-//  if (!has)ReportError("The aiScene data structure is empty");
-    ASSIMP_LOG_DEBUG("ValidateDataStructureProcess end");
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiLight* pLight)
-{
-    if (pLight->mType == aiLightSource_UNDEFINED)
-        ReportWarning("aiLight::mType is aiLightSource_UNDEFINED");
-
-    if (!pLight->mAttenuationConstant &&
-        !pLight->mAttenuationLinear   &&
-        !pLight->mAttenuationQuadratic) {
-        ReportWarning("aiLight::mAttenuationXXX - all are zero");
-    }
-
-    if (pLight->mAngleInnerCone > pLight->mAngleOuterCone)
-        ReportError("aiLight::mAngleInnerCone is larger than aiLight::mAngleOuterCone");
-
-    if (pLight->mColorDiffuse.IsBlack() && pLight->mColorAmbient.IsBlack()
-        && pLight->mColorSpecular.IsBlack())
-    {
-        ReportWarning("aiLight::mColorXXX - all are black and won't have any influence");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiCamera* pCamera)
-{
-    if (pCamera->mClipPlaneFar <= pCamera->mClipPlaneNear)
-        ReportError("aiCamera::mClipPlaneFar must be >= aiCamera::mClipPlaneNear");
-
-    // FIX: there are many 3ds files with invalid FOVs. No reason to
-    // reject them at all ... a warning is appropriate.
-    if (!pCamera->mHorizontalFOV || pCamera->mHorizontalFOV >= (float)AI_MATH_PI)
-        ReportWarning("%f is not a valid value for aiCamera::mHorizontalFOV",pCamera->mHorizontalFOV);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiMesh* pMesh)
-{
-    // validate the material index of the mesh
-    if (mScene->mNumMaterials && pMesh->mMaterialIndex >= mScene->mNumMaterials)
-    {
-        ReportError("aiMesh::mMaterialIndex is invalid (value: %i maximum: %i)",
-            pMesh->mMaterialIndex,mScene->mNumMaterials-1);
-    }
-
-    Validate(&pMesh->mName);
-
-    for (unsigned int i = 0; i < pMesh->mNumFaces; ++i)
-    {
-        aiFace& face = pMesh->mFaces[i];
-
-        if (pMesh->mPrimitiveTypes)
-        {
-            switch (face.mNumIndices)
-            {
-            case 0:
-                ReportError("aiMesh::mFaces[%i].mNumIndices is 0",i);
-                break;
-            case 1:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_POINT))
-                {
-                    ReportError("aiMesh::mFaces[%i] is a POINT but aiMesh::mPrimitiveTypes "
-                        "does not report the POINT flag",i);
-                }
-                break;
-            case 2:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_LINE))
-                {
-                    ReportError("aiMesh::mFaces[%i] is a LINE but aiMesh::mPrimitiveTypes "
-                        "does not report the LINE flag",i);
-                }
-                break;
-            case 3:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE))
-                {
-                    ReportError("aiMesh::mFaces[%i] is a TRIANGLE but aiMesh::mPrimitiveTypes "
-                        "does not report the TRIANGLE flag",i);
-                }
-                break;
-            default:
-                if (0 == (pMesh->mPrimitiveTypes & aiPrimitiveType_POLYGON))
-                {
-                    this->ReportError("aiMesh::mFaces[%i] is a POLYGON but aiMesh::mPrimitiveTypes "
-                        "does not report the POLYGON flag",i);
-                }
-                break;
-            };
-        }
-
-        if (!face.mIndices)
-            ReportError("aiMesh::mFaces[%i].mIndices is NULL",i);
-    }
-
-    // positions must always be there ...
-    if (!pMesh->mNumVertices || (!pMesh->mVertices && !mScene->mFlags)) {
-        ReportError("The mesh %s contains no vertices", pMesh->mName.C_Str());
-    }
-
-    if (pMesh->mNumVertices > AI_MAX_VERTICES) {
-        ReportError("Mesh has too many vertices: %u, but the limit is %u",pMesh->mNumVertices,AI_MAX_VERTICES);
-    }
-    if (pMesh->mNumFaces > AI_MAX_FACES) {
-        ReportError("Mesh has too many faces: %u, but the limit is %u",pMesh->mNumFaces,AI_MAX_FACES);
-    }
-
-    // if tangents are there there must also be bitangent vectors ...
-    if ((pMesh->mTangents != NULL) != (pMesh->mBitangents != NULL)) {
-        ReportError("If there are tangents, bitangent vectors must be present as well");
-    }
-
-    // faces, too
-    if (!pMesh->mNumFaces || (!pMesh->mFaces && !mScene->mFlags))   {
-        ReportError("Mesh %s contains no faces", pMesh->mName.C_Str());
-    }
-
-    // now check whether the face indexing layout is correct:
-    // unique vertices, pseudo-indexed.
-    std::vector<bool> abRefList;
-    abRefList.resize(pMesh->mNumVertices,false);
-    for (unsigned int i = 0; i < pMesh->mNumFaces;++i)
-    {
-        aiFace& face = pMesh->mFaces[i];
-        if (face.mNumIndices > AI_MAX_FACE_INDICES) {
-            ReportError("Face %u has too many faces: %u, but the limit is %u",i,face.mNumIndices,AI_MAX_FACE_INDICES);
-        }
-
-        for (unsigned int a = 0; a < face.mNumIndices;++a)
-        {
-            if (face.mIndices[a] >= pMesh->mNumVertices)    {
-                ReportError("aiMesh::mFaces[%i]::mIndices[%i] is out of range",i,a);
-            }
-            // the MSB flag is temporarily used by the extra verbose
-            // mode to tell us that the JoinVerticesProcess might have
-            // been executed already.
-			/*if ( !(this->mScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT ) && !(this->mScene->mFlags & AI_SCENE_FLAGS_ALLOW_SHARED) &&
-				abRefList[face.mIndices[a]])
-            {
-                ReportError("aiMesh::mVertices[%i] is referenced twice - second "
-                    "time by aiMesh::mFaces[%i]::mIndices[%i]",face.mIndices[a],i,a);
-            }*/
-            abRefList[face.mIndices[a]] = true;
-        }
-    }
-
-    // check whether there are vertices that aren't referenced by a face
-    bool b = false;
-    for (unsigned int i = 0; i < pMesh->mNumVertices;++i)   {
-        if (!abRefList[i])b = true;
-    }
-    abRefList.clear();
-    if (b) {
-    	ReportWarning("There are unreferenced vertices");
-    }
-
-    // texture channel 2 may not be set if channel 1 is zero ...
-    {
-        unsigned int i = 0;
-        for (;i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
-        {
-            if (!pMesh->HasTextureCoords(i))break;
-        }
-        for (;i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)
-            if (pMesh->HasTextureCoords(i))
-            {
-                ReportError("Texture coordinate channel %i exists "
-                    "although the previous channel was NULL.",i);
-            }
-    }
-    // the same for the vertex colors
-    {
-        unsigned int i = 0;
-        for (;i < AI_MAX_NUMBER_OF_COLOR_SETS;++i)
-        {
-            if (!pMesh->HasVertexColors(i))break;
-        }
-        for (;i < AI_MAX_NUMBER_OF_COLOR_SETS;++i)
-            if (pMesh->HasVertexColors(i))
-            {
-                ReportError("Vertex color channel %i is exists "
-                    "although the previous channel was NULL.",i);
-            }
-    }
-
-
-    // now validate all bones
-    if (pMesh->mNumBones)
-    {
-        if (!pMesh->mBones)
-        {
-            ReportError("aiMesh::mBones is NULL (aiMesh::mNumBones is %i)",
-                pMesh->mNumBones);
-        }
-        std::unique_ptr<float[]> afSum(nullptr);
-        if (pMesh->mNumVertices)
-        {
-            afSum.reset(new float[pMesh->mNumVertices]);
-            for (unsigned int i = 0; i < pMesh->mNumVertices;++i)
-                afSum[i] = 0.0f;
-        }
-
-        // check whether there are duplicate bone names
-        for (unsigned int i = 0; i < pMesh->mNumBones;++i)
-        {
-            const aiBone* bone = pMesh->mBones[i];
-            if (bone->mNumWeights > AI_MAX_BONE_WEIGHTS) {
-                ReportError("Bone %u has too many weights: %u, but the limit is %u",i,bone->mNumWeights,AI_MAX_BONE_WEIGHTS);
-            }
-
-            if (!pMesh->mBones[i])
-            {
-                ReportError("aiMesh::mBones[%i] is NULL (aiMesh::mNumBones is %i)",
-                    i,pMesh->mNumBones);
-            }
-            Validate(pMesh,pMesh->mBones[i],afSum.get());
-
-            for (unsigned int a = i+1; a < pMesh->mNumBones;++a)
-            {
-                if (pMesh->mBones[i]->mName == pMesh->mBones[a]->mName)
-                {
-                    const char *name = "unknown";
-                    if (nullptr != pMesh->mBones[ i ]->mName.C_Str()) {
-                        name = pMesh->mBones[ i ]->mName.C_Str();
-                    }
-                    ReportError("aiMesh::mBones[%i], name = \"%s\" has the same name as "
-                        "aiMesh::mBones[%i]", i, name, a );
-                }
-            }
-        }
-        // check whether all bone weights for a vertex sum to 1.0 ...
-        for (unsigned int i = 0; i < pMesh->mNumVertices;++i)
-        {
-            if (afSum[i] && (afSum[i] <= 0.94 || afSum[i] >= 1.05)) {
-                ReportWarning("aiMesh::mVertices[%i]: bone weight sum != 1.0 (sum is %f)",i,afSum[i]);
-            }
-        }
-    }
-    else if (pMesh->mBones)
-    {
-        ReportError("aiMesh::mBones is non-null although there are no bones");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiMesh* pMesh, const aiBone* pBone,float* afSum) {
-    this->Validate(&pBone->mName);
-
-    if (!pBone->mNumWeights)    {
-        //ReportError("aiBone::mNumWeights is zero");
-    }
-
-    // check whether all vertices affected by this bone are valid
-    for (unsigned int i = 0; i < pBone->mNumWeights;++i)
-    {
-        if (pBone->mWeights[i].mVertexId >= pMesh->mNumVertices)    {
-            ReportError("aiBone::mWeights[%i].mVertexId is out of range",i);
-        }
-        else if (!pBone->mWeights[i].mWeight || pBone->mWeights[i].mWeight > 1.0f)  {
-            ReportWarning("aiBone::mWeights[%i].mWeight has an invalid value",i);
-        }
-        afSum[pBone->mWeights[i].mVertexId] += pBone->mWeights[i].mWeight;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiAnimation* pAnimation)
-{
-    Validate(&pAnimation->mName);
-
-    // validate all animations
-    if (pAnimation->mNumChannels || pAnimation->mNumMorphMeshChannels)
-    {
-        if (!pAnimation->mChannels && pAnimation->mNumChannels) {
-            ReportError("aiAnimation::mChannels is NULL (aiAnimation::mNumChannels is %i)",
-                pAnimation->mNumChannels);
-        }
-        if (!pAnimation->mMorphMeshChannels && pAnimation->mNumMorphMeshChannels) {
-            ReportError("aiAnimation::mMorphMeshChannels is NULL (aiAnimation::mNumMorphMeshChannels is %i)",
-                pAnimation->mNumMorphMeshChannels);
-        }
-        for (unsigned int i = 0; i < pAnimation->mNumChannels;++i)
-        {
-            if (!pAnimation->mChannels[i])
-            {
-                ReportError("aiAnimation::mChannels[%i] is NULL (aiAnimation::mNumChannels is %i)",
-                    i, pAnimation->mNumChannels);
-            }
-            Validate(pAnimation, pAnimation->mChannels[i]);
-        }
-        for (unsigned int i = 0; i < pAnimation->mNumMorphMeshChannels;++i)
-        {
-            if (!pAnimation->mMorphMeshChannels[i])
-            {
-                ReportError("aiAnimation::mMorphMeshChannels[%i] is NULL (aiAnimation::mNumMorphMeshChannels is %i)",
-                    i, pAnimation->mNumMorphMeshChannels);
-            }
-            Validate(pAnimation, pAnimation->mMorphMeshChannels[i]);
-        }
-    }
-    else {
-    	ReportError("aiAnimation::mNumChannels is 0. At least one node animation channel must be there.");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
-    aiTextureType type)
-{
-    const char* szType = TextureTypeToString(type);
-
-    // ****************************************************************************
-    // Search all keys of the material ...
-    // textures must be specified with ascending indices
-    // (e.g. diffuse #2 may not be specified if diffuse #1 is not there ...)
-    // ****************************************************************************
-
-    int iNumIndices = 0;
-    int iIndex = -1;
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i) {
-        aiMaterialProperty* prop = pMaterial->mProperties[ i ];
-        ai_assert(nullptr != prop);
-        if ( !::strcmp(prop->mKey.data,"$tex.file") && prop->mSemantic == static_cast<unsigned int>(type))  {
-            iIndex = std::max(iIndex, (int) prop->mIndex);
-            ++iNumIndices;
-
-            if (aiPTI_String != prop->mType) {
-                ReportError("Material property %s is expected to be a string", prop->mKey.data);
-            }
-        }
-    }
-    if (iIndex +1 != iNumIndices)   {
-        ReportError("%s #%i is set, but there are only %i %s textures",
-            szType,iIndex,iNumIndices,szType);
-    }
-    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)
-    {
-        aiMaterialProperty* prop = pMaterial->mProperties[i];
-        if (prop->mSemantic != type)continue;
-
-        if ((int)prop->mIndex >= iNumIndices)
-        {
-            ReportError("Found texture property with index %i, although there "
-                "are only %i textures of type %s",
-                prop->mIndex, iNumIndices, szType);
-        }
-
-        if (!::strcmp(prop->mKey.data,"$tex.mapping"))  {
-            if (aiPTI_Integer != prop->mType || prop->mDataLength < sizeof(aiTextureMapping))
-            {
-                ReportError("Material property %s%i is expected to be an integer (size is %i)",
-                    prop->mKey.data,prop->mIndex,prop->mDataLength);
-            }
-            mappings[prop->mIndex] = *((aiTextureMapping*)prop->mData);
-        }
-        else if (!::strcmp(prop->mKey.data,"$tex.uvtrafo")) {
-            if (aiPTI_Float != prop->mType || prop->mDataLength < sizeof(aiUVTransform))
-            {
-                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] = *((aiTextureMapping*)prop->mData);
-        }
-        else if (!::strcmp(prop->mKey.data,"$tex.uvwsrc")) {
-            if (aiPTI_Integer != prop->mType || sizeof(int) > prop->mDataLength)
-            {
-                ReportError("Material property %s%i is expected to be an integer (size is %i)",
-                    prop->mKey.data,prop->mIndex,prop->mDataLength);
-            }
-            bNoSpecified = false;
-
-            // Ignore UV indices for texture channels that are not there ...
-
-            // Get the value
-            iIndex = *((unsigned int*)prop->mData);
-
-            // Check whether there is a mesh using this material
-            // which has not enough UV channels ...
-            for (unsigned int a = 0; a < mScene->mNumMeshes;++a)
-            {
-                aiMesh* mesh = this->mScene->mMeshes[a];
-                if(mesh->mMaterialIndex == (unsigned int)i)
-                {
-                    int iChannels = 0;
-                    while (mesh->HasTextureCoords(iChannels))++iChannels;
-                    if (iIndex >= iChannels)
-                    {
-                        ReportWarning("Invalid UV index: %i (key %s). Mesh %i has only %i UV channels",
-                            iIndex,prop->mKey.data,a,iChannels);
-                    }
-                }
-            }
-        }
-    }
-    if (bNoSpecified)
-    {
-        // Assume that all textures are using the first UV channel
-        for (unsigned int a = 0; a < mScene->mNumMeshes;++a)
-        {
-            aiMesh* mesh = mScene->mMeshes[a];
-            if(mesh->mMaterialIndex == (unsigned int)iIndex && mappings[0] == aiTextureMapping_UV)
-            {
-                if (!mesh->mTextureCoords[0])
-                {
-                    // This is a special case ... it could be that the
-                    // original mesh format intended the use of a special
-                    // mapping here.
-                    ReportWarning("UV-mapped texture, but there are no UV coords");
-                }
-            }
-        }
-    }
-}
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiMaterial* pMaterial)
-{
-    // check whether there are material keys that are obviously not legal
-    for (unsigned int i = 0; i < pMaterial->mNumProperties;++i)
-    {
-        const aiMaterialProperty* prop = pMaterial->mProperties[i];
-        if (!prop)  {
-            ReportError("aiMaterial::mProperties[%i] is NULL (aiMaterial::mNumProperties is %i)",
-                i,pMaterial->mNumProperties);
-        }
-        if (!prop->mDataLength || !prop->mData) {
-            ReportError("aiMaterial::mProperties[%i].mDataLength or "
-                "aiMaterial::mProperties[%i].mData is 0",i,i);
-        }
-        // check all predefined types
-        if (aiPTI_String == prop->mType)    {
-            // FIX: strings are now stored in a less expensive way, but we can't use the
-            // validation routine for 'normal' aiStrings
-            if (prop->mDataLength < 5 || prop->mDataLength < 4 + (*reinterpret_cast<uint32_t*>(prop->mData)) + 1)   {
-                ReportError("aiMaterial::mProperties[%i].mDataLength is "
-                    "too small to contain a string (%i, needed: %i)",
-                    i,prop->mDataLength,static_cast<int>(sizeof(aiString)));
-            }
-            if(prop->mData[prop->mDataLength-1]) {
-                ReportError("Missing null-terminator in string material property");
-            }
-        //  Validate((const aiString*)prop->mData);
-        }
-        else if (aiPTI_Float == prop->mType)    {
-            if (prop->mDataLength < sizeof(float))  {
-                ReportError("aiMaterial::mProperties[%i].mDataLength is "
-                    "too small to contain a float (%i, needed: %i)",
-                    i,prop->mDataLength, static_cast<int>(sizeof(float)));
-            }
-        }
-        else if (aiPTI_Integer == prop->mType)  {
-            if (prop->mDataLength < sizeof(int))    {
-                ReportError("aiMaterial::mProperties[%i].mDataLength is "
-                    "too small to contain an integer (%i, needed: %i)",
-                    i,prop->mDataLength, static_cast<int>(sizeof(int)));
-            }
-        }
-        // TODO: check whether there is a key with an unknown name ...
-    }
-
-    // make some more specific tests
-    ai_real fTemp;
-    int iShading;
-    if (AI_SUCCESS == aiGetMaterialInteger( pMaterial,AI_MATKEY_SHADING_MODEL,&iShading))   {
-        switch ((aiShadingMode)iShading)
-        {
-        case aiShadingMode_Blinn:
-        case aiShadingMode_CookTorrance:
-        case aiShadingMode_Phong:
-
-            if (AI_SUCCESS != aiGetMaterialFloat(pMaterial,AI_MATKEY_SHININESS,&fTemp)) {
-                ReportWarning("A specular shading model is specified but there is no "
-                    "AI_MATKEY_SHININESS key");
-            }
-            if (AI_SUCCESS == aiGetMaterialFloat(pMaterial,AI_MATKEY_SHININESS_STRENGTH,&fTemp) && !fTemp)  {
-                ReportWarning("A specular shading model is specified but the value of the "
-                    "AI_MATKEY_SHININESS_STRENGTH key is 0.0");
-            }
-            break;
-        default:
-            break;
-        }
-    }
-
-    if (AI_SUCCESS == aiGetMaterialFloat( pMaterial,AI_MATKEY_OPACITY,&fTemp) && (!fTemp || fTemp > 1.01)) {
-        ReportWarning("Invalid opacity value (must be 0 < opacity < 1.0)");
-    }
-
-    // Check whether there are invalid texture keys
-    // TODO: that's a relict of the past, where texture type and index were baked
-    // into the material string ... we could do that in one single pass.
-    SearchForInvalidTextures(pMaterial,aiTextureType_DIFFUSE);
-    SearchForInvalidTextures(pMaterial,aiTextureType_SPECULAR);
-    SearchForInvalidTextures(pMaterial,aiTextureType_AMBIENT);
-    SearchForInvalidTextures(pMaterial,aiTextureType_EMISSIVE);
-    SearchForInvalidTextures(pMaterial,aiTextureType_OPACITY);
-    SearchForInvalidTextures(pMaterial,aiTextureType_SHININESS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_HEIGHT);
-    SearchForInvalidTextures(pMaterial,aiTextureType_NORMALS);
-    SearchForInvalidTextures(pMaterial,aiTextureType_DISPLACEMENT);
-    SearchForInvalidTextures(pMaterial,aiTextureType_LIGHTMAP);
-    SearchForInvalidTextures(pMaterial,aiTextureType_REFLECTION);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiTexture* pTexture)
-{
-    // the data section may NEVER be NULL
-    if (!pTexture->pcData)  {
-        ReportError("aiTexture::pcData is NULL");
-    }
-    if (pTexture->mHeight)
-    {
-        if (!pTexture->mWidth){
-        	ReportError("aiTexture::mWidth is zero (aiTexture::mHeight is %i, uncompressed texture)",
-        			pTexture->mHeight);
-        }
-    }
-    else
-    {
-        if (!pTexture->mWidth) {
-            ReportError("aiTexture::mWidth is zero (compressed texture)");
-        }
-        if ('\0' != pTexture->achFormatHint[3]) {
-            ReportWarning("aiTexture::achFormatHint must be zero-terminated");
-        }
-        else if ('.'  == pTexture->achFormatHint[0])    {
-            ReportWarning("aiTexture::achFormatHint should contain a file extension "
-                "without a leading dot (format hint: %s).",pTexture->achFormatHint);
-        }
-    }
-
-    const char* sz = pTexture->achFormatHint;
-    if ((sz[0] >= 'A' && sz[0] <= 'Z') ||
-        (sz[1] >= 'A' && sz[1] <= 'Z') ||
-        (sz[2] >= 'A' && sz[2] <= 'Z') ||
-        (sz[3] >= 'A' && sz[3] <= 'Z')) {
-        ReportError("aiTexture::achFormatHint contains non-lowercase letters");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiAnimation* pAnimation,
-     const aiNodeAnim* pNodeAnim)
-{
-    Validate(&pNodeAnim->mNodeName);
-
-    if (!pNodeAnim->mNumPositionKeys && !pNodeAnim->mScalingKeys && !pNodeAnim->mNumRotationKeys) {
-        ReportError("Empty node animation channel");
-    }
-    // otherwise check whether one of the keys exceeds the total duration of the animation
-    if (pNodeAnim->mNumPositionKeys)
-    {
-        if (!pNodeAnim->mPositionKeys)
-        {
-        	ReportError("aiNodeAnim::mPositionKeys is NULL (aiNodeAnim::mNumPositionKeys is %i)",
-                pNodeAnim->mNumPositionKeys);
-        }
-        double dLast = -10e10;
-        for (unsigned int i = 0; i < pNodeAnim->mNumPositionKeys;++i)
-        {
-            // ScenePreprocessor will compute the duration if still the default value
-            // (Aramis) Add small epsilon, comparison tended to fail if max_time == duration,
-            //  seems to be due the compilers register usage/width.
-            if (pAnimation->mDuration > 0. && pNodeAnim->mPositionKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
-                ReportError("aiNodeAnim::mPositionKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pNodeAnim->mPositionKeys[i].mTime,
-                    (float)pAnimation->mDuration);
-            }
-            if (i && pNodeAnim->mPositionKeys[i].mTime <= dLast)
-            {
-                ReportWarning("aiNodeAnim::mPositionKeys[%i].mTime (%.5f) is smaller "
-                    "than aiAnimation::mPositionKeys[%i] (which is %.5f)",i,
-                    (float)pNodeAnim->mPositionKeys[i].mTime,
-                    i-1, (float)dLast);
-            }
-            dLast = pNodeAnim->mPositionKeys[i].mTime;
-        }
-    }
-    // rotation keys
-    if (pNodeAnim->mNumRotationKeys)
-    {
-        if (!pNodeAnim->mRotationKeys)
-        {
-            ReportError("aiNodeAnim::mRotationKeys is NULL (aiNodeAnim::mNumRotationKeys is %i)",
-                pNodeAnim->mNumRotationKeys);
-        }
-        double dLast = -10e10;
-        for (unsigned int i = 0; i < pNodeAnim->mNumRotationKeys;++i)
-        {
-            if (pAnimation->mDuration > 0. && pNodeAnim->mRotationKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
-                ReportError("aiNodeAnim::mRotationKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pNodeAnim->mRotationKeys[i].mTime,
-                    (float)pAnimation->mDuration);
-            }
-            if (i && pNodeAnim->mRotationKeys[i].mTime <= dLast)
-            {
-                ReportWarning("aiNodeAnim::mRotationKeys[%i].mTime (%.5f) is smaller "
-                    "than aiAnimation::mRotationKeys[%i] (which is %.5f)",i,
-                    (float)pNodeAnim->mRotationKeys[i].mTime,
-                    i-1, (float)dLast);
-            }
-            dLast = pNodeAnim->mRotationKeys[i].mTime;
-        }
-    }
-    // scaling keys
-    if (pNodeAnim->mNumScalingKeys)
-    {
-        if (!pNodeAnim->mScalingKeys)   {
-            ReportError("aiNodeAnim::mScalingKeys is NULL (aiNodeAnim::mNumScalingKeys is %i)",
-                pNodeAnim->mNumScalingKeys);
-        }
-        double dLast = -10e10;
-        for (unsigned int i = 0; i < pNodeAnim->mNumScalingKeys;++i)
-        {
-            if (pAnimation->mDuration > 0. && pNodeAnim->mScalingKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
-                ReportError("aiNodeAnim::mScalingKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pNodeAnim->mScalingKeys[i].mTime,
-                    (float)pAnimation->mDuration);
-            }
-            if (i && pNodeAnim->mScalingKeys[i].mTime <= dLast)
-            {
-                ReportWarning("aiNodeAnim::mScalingKeys[%i].mTime (%.5f) is smaller "
-                    "than aiAnimation::mScalingKeys[%i] (which is %.5f)",i,
-                    (float)pNodeAnim->mScalingKeys[i].mTime,
-                    i-1, (float)dLast);
-            }
-            dLast = pNodeAnim->mScalingKeys[i].mTime;
-        }
-    }
-
-    if (!pNodeAnim->mNumScalingKeys && !pNodeAnim->mNumRotationKeys &&
-        !pNodeAnim->mNumPositionKeys)
-    {
-        ReportError("A node animation channel must have at least one subtrack");
-    }
-}
-
-void ValidateDSProcess::Validate( const aiAnimation* pAnimation,
-     const aiMeshMorphAnim* pMeshMorphAnim)
-{
-    Validate(&pMeshMorphAnim->mName);
-
-    if (!pMeshMorphAnim->mNumKeys) {
-        ReportError("Empty mesh morph animation channel");
-    }
-
-    // otherwise check whether one of the keys exceeds the total duration of the animation
-    if (pMeshMorphAnim->mNumKeys)
-    {
-        if (!pMeshMorphAnim->mKeys)
-        {
-            ReportError("aiMeshMorphAnim::mKeys is NULL (aiMeshMorphAnim::mNumKeys is %i)",
-                pMeshMorphAnim->mNumKeys);
-        }
-        double dLast = -10e10;
-        for (unsigned int i = 0; i < pMeshMorphAnim->mNumKeys;++i)
-        {
-            // ScenePreprocessor will compute the duration if still the default value
-            // (Aramis) Add small epsilon, comparison tended to fail if max_time == duration,
-            //  seems to be due the compilers register usage/width.
-            if (pAnimation->mDuration > 0. && pMeshMorphAnim->mKeys[i].mTime > pAnimation->mDuration+0.001)
-            {
-                ReportError("aiMeshMorphAnim::mKeys[%i].mTime (%.5f) is larger "
-                    "than aiAnimation::mDuration (which is %.5f)",i,
-                    (float)pMeshMorphAnim->mKeys[i].mTime,
-                    (float)pAnimation->mDuration);
-            }
-            if (i && pMeshMorphAnim->mKeys[i].mTime <= dLast)
-            {
-                ReportWarning("aiMeshMorphAnim::mKeys[%i].mTime (%.5f) is smaller "
-                    "than aiMeshMorphAnim::mKeys[%i] (which is %.5f)",i,
-                    (float)pMeshMorphAnim->mKeys[i].mTime,
-                    i-1, (float)dLast);
-            }
-            dLast = pMeshMorphAnim->mKeys[i].mTime;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiNode* pNode)
-{
-    if (!pNode) {
-    	ReportError("A node of the scenegraph is NULL");
-    }
-    // Validate node name string first so that it's safe to use in below expressions
-    this->Validate(&pNode->mName);
-    const char* nodeName = (&pNode->mName)->C_Str();
-    if (pNode != mScene->mRootNode && !pNode->mParent){
-        ReportError("Non-root node %s lacks a valid parent (aiNode::mParent is NULL) ", nodeName);
-    }
-
-    // validate all meshes
-    if (pNode->mNumMeshes)
-    {
-        if (!pNode->mMeshes)
-        {
-            ReportError("aiNode::mMeshes is NULL for node %s (aiNode::mNumMeshes is %i)",
-            		  nodeName, pNode->mNumMeshes);
-        }
-        std::vector<bool> abHadMesh;
-        abHadMesh.resize(mScene->mNumMeshes,false);
-        for (unsigned int i = 0; i < pNode->mNumMeshes;++i)
-        {
-            if (pNode->mMeshes[i] >= mScene->mNumMeshes)
-            {
-                ReportError("aiNode::mMeshes[%i] is out of range for node %s (maximum is %i)",
-                    pNode->mMeshes[i], nodeName, mScene->mNumMeshes-1);
-            }
-            if (abHadMesh[pNode->mMeshes[i]])
-            {
-                ReportError("aiNode::mMeshes[%i] is already referenced by this node %s (value: %i)",
-                    i, nodeName, pNode->mMeshes[i]);
-            }
-            abHadMesh[pNode->mMeshes[i]] = true;
-        }
-    }
-    if (pNode->mNumChildren)
-    {
-        if (!pNode->mChildren)  {
-            ReportError("aiNode::mChildren is NULL for node %s (aiNode::mNumChildren is %i)",
-            		nodeName, pNode->mNumChildren);
-        }
-        for (unsigned int i = 0; i < pNode->mNumChildren;++i)   {
-            Validate(pNode->mChildren[i]);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void ValidateDSProcess::Validate( const aiString* pString)
-{
-    if (pString->length > MAXLEN)
-    {
-        ReportError("aiString::length is too large (%u, maximum is %lu)",
-            pString->length,MAXLEN);
-    }
-    const char* sz = pString->data;
-    while (true)
-    {
-        if ('\0' == *sz)
-        {
-            if (pString->length != (unsigned int)(sz-pString->data)) {
-                ReportError("aiString::data is invalid: the terminal zero is at a wrong offset");
-            }
-            break;
-        }
-        else if (sz >= &pString->data[MAXLEN]) {
-            ReportError("aiString::data is invalid. There is no terminal character");
-        }
-        ++sz;
-    }
-}
diff --git a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h b/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h
deleted file mode 100644
index 7b309c9251..0000000000
--- a/thirdparty/assimp/code/PostProcessing/ValidateDataStructure.h
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2019, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-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.
-
-----------------------------------------------------------------------
-*/
-
-/** @file Defines a (dummy) post processing step to validate the loader's
- * output data structure (for debugging)
- */
-#ifndef AI_VALIDATEPROCESS_H_INC
-#define AI_VALIDATEPROCESS_H_INC
-
-#include <assimp/types.h>
-#include <assimp/material.h>
-
-#include "Common/BaseProcess.h"
-
-struct aiBone;
-struct aiMesh;
-struct aiAnimation;
-struct aiNodeAnim;
-struct aiMeshMorphAnim;
-struct aiTexture;
-struct aiMaterial;
-struct aiNode;
-struct aiString;
-struct aiCamera;
-struct aiLight;
-
-namespace Assimp    {
-
-// --------------------------------------------------------------------------------------
-/** Validates the whole ASSIMP scene data structure for correctness.
- *  ImportErrorException is thrown of the scene is corrupt.*/
-// --------------------------------------------------------------------------------------
-class ValidateDSProcess : public BaseProcess
-{
-public:
-
-    ValidateDSProcess();
-    ~ValidateDSProcess();
-
-public:
-    // -------------------------------------------------------------------
-    bool IsActive( unsigned int pFlags) const;
-
-    // -------------------------------------------------------------------
-    void Execute( aiScene* pScene);
-
-protected:
-
-    // -------------------------------------------------------------------
-    /** Report a validation error. This will throw an exception,
-     *  control won't return.
-     * @param msg Format string for sprintf().*/
-    AI_WONT_RETURN void ReportError(const char* msg,...) AI_WONT_RETURN_SUFFIX;
-
-
-    // -------------------------------------------------------------------
-    /** Report a validation warning. This won't throw an exception,
-     *  control will return to the caller.
-     * @param msg Format string for sprintf().*/
-    void ReportWarning(const char* msg,...);
-
-
-    // -------------------------------------------------------------------
-    /** Validates a mesh
-     * @param pMesh Input mesh*/
-    void Validate( const aiMesh* pMesh);
-
-    // -------------------------------------------------------------------
-    /** Validates a bone
-     * @param pMesh Input mesh
-     * @param pBone Input bone*/
-    void Validate( const aiMesh* pMesh,const aiBone* pBone,float* afSum);
-
-    // -------------------------------------------------------------------
-    /** Validates an animation
-     * @param pAnimation Input animation*/
-    void Validate( const aiAnimation* pAnimation);
-
-    // -------------------------------------------------------------------
-    /** Validates a material
-     * @param pMaterial Input material*/
-    void Validate( const aiMaterial* pMaterial);
-
-    // -------------------------------------------------------------------
-    /** Search the material data structure for invalid or corrupt
-     *  texture keys.
-     * @param pMaterial Input material
-     * @param type Type of the texture*/
-    void SearchForInvalidTextures(const aiMaterial* pMaterial,
-        aiTextureType type);
-
-    // -------------------------------------------------------------------
-    /** Validates a texture
-     * @param pTexture Input texture*/
-    void Validate( const aiTexture* pTexture);
-
-    // -------------------------------------------------------------------
-    /** Validates a light source
-     * @param pLight Input light
-     */
-    void Validate( const aiLight* pLight);
-
-    // -------------------------------------------------------------------
-    /** Validates a camera
-     * @param pCamera Input camera*/
-    void Validate( const aiCamera* pCamera);
-
-    // -------------------------------------------------------------------
-    /** Validates a bone animation channel
-     * @param pAnimation Animation channel.
-     * @param pBoneAnim Input bone animation */
-    void Validate( const aiAnimation* pAnimation,
-        const aiNodeAnim* pBoneAnim);
-
-    /** Validates a mesh morph animation channel.
-     * @param pAnimation Input animation.
-     * @param pMeshMorphAnim Mesh morph animation channel.
-     * */
-    void Validate( const aiAnimation* pAnimation,
-        const aiMeshMorphAnim* pMeshMorphAnim);
-
-    // -------------------------------------------------------------------
-    /** Validates a node and all of its subnodes
-     * @param Node Input node*/
-    void Validate( const aiNode* pNode);
-
-    // -------------------------------------------------------------------
-    /** Validates a string
-     * @param pString Input string*/
-    void Validate( const aiString* pString);
-
-private:
-
-    // template to validate one of the aiScene::mXXX arrays
-    template <typename T>
-    inline void DoValidation(T** array, unsigned int size,
-        const char* firstName, const char* secondName);
-
-    // extended version: checks whether T::mName occurs twice
-    template <typename T>
-    inline void DoValidationEx(T** array, unsigned int size,
-        const char* firstName, const char* secondName);
-
-    // extension to the first template which does also search
-    // the nodegraph for an item with the same name
-    template <typename T>
-    inline void DoValidationWithNameCheck(T** array, unsigned int size,
-        const char* firstName, const char* secondName);
-
-    aiScene* mScene;
-};
-
-
-
-
-} // end of namespace Assimp
-
-#endif // AI_VALIDATEPROCESS_H_INC