Merge branch 'master' into fbx_tokenizer_fix

CMakeLists.txt

@@ -34,6 +34,7 @@
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #----------------------------------------------------------------------
+SET(CMAKE_POLICY_DEFAULT_CMP0012 NEW)
 SET(CMAKE_POLICY_DEFAULT_CMP0074 NEW)
 SET(CMAKE_POLICY_DEFAULT_CMP0092 NEW)
 

code/AssetLib/Collada/ColladaHelper.cpp

@@ -53,7 +53,7 @@ const MetaKeyPairVector MakeColladaAssimpMetaKeys() {
     result.emplace_back("authoring_tool", AI_METADATA_SOURCE_GENERATOR);
     result.emplace_back("copyright", AI_METADATA_SOURCE_COPYRIGHT);
     return result;
-};
+}
 
 const MetaKeyPairVector &GetColladaAssimpMetaKeys() {
     static const MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
@@ -66,7 +66,7 @@ const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() {
         ToCamelCase(val.first);
     }
     return result;
-};
+}
 
 const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase() {
     static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase();

code/AssetLib/FBX/FBXConverter.cpp

@@ -79,7 +79,7 @@ using namespace Util;
 
 #define MAGIC_NODE_TAG "_$AssimpFbx$"
 
-#define CONVERT_FBX_TIME(time) static_cast<double>(time) / 46186158000LL
+#define CONVERT_FBX_TIME(time) (static_cast<double>(time) * 1000.0 / 46186158000LL)
 
 FBXConverter::FBXConverter(aiScene *out, const Document &doc, bool removeEmptyBones) :
         defaultMaterialIndex(),
@@ -2560,7 +2560,7 @@ void FBXConverter::ConvertAnimationStack(const AnimationStack &st) {
                     meshMorphAnim->mKeys[j].mNumValuesAndWeights = numValuesAndWeights;
                     meshMorphAnim->mKeys[j].mValues = new unsigned int[numValuesAndWeights];
                     meshMorphAnim->mKeys[j].mWeights = new double[numValuesAndWeights];
-                    meshMorphAnim->mKeys[j].mTime = CONVERT_FBX_TIME(animIt.first) * anim_fps;
+                    meshMorphAnim->mKeys[j].mTime = CONVERT_FBX_TIME(animIt.first);
                     for (unsigned int k = 0; k < numValuesAndWeights; k++) {
                         meshMorphAnim->mKeys[j].mValues[k] = keyData->values.at(k);
                         meshMorphAnim->mKeys[j].mWeights[k] = keyData->weights.at(k);
@@ -2578,8 +2578,8 @@ void FBXConverter::ConvertAnimationStack(const AnimationStack &st) {
         return;
     }
 
-    double start_time_fps = has_local_startstop ? (CONVERT_FBX_TIME(start_time) * anim_fps) : min_time;
+    double start_time_fps = has_local_startstop ? CONVERT_FBX_TIME(start_time) : min_time;
-    double stop_time_fps = has_local_startstop ? (CONVERT_FBX_TIME(stop_time) * anim_fps) : max_time;
+    double stop_time_fps = has_local_startstop ? CONVERT_FBX_TIME(stop_time) : max_time;
 
     // adjust relative timing for animation
     for (unsigned int c = 0; c < anim->mNumChannels; c++) {
@@ -3099,7 +3099,7 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name,
         InterpolateKeys(outTranslations, keytimes, keyframeLists[TransformationComp_Translation], defTranslate, maxTime, minTime);
     } else {
         for (size_t i = 0; i < keyCount; ++i) {
-            outTranslations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outTranslations[i].mTime = CONVERT_FBX_TIME(keytimes[i]);
             outTranslations[i].mValue = defTranslate;
         }
     }
@@ -3108,7 +3108,7 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name,
         InterpolateKeys(outRotations, keytimes, keyframeLists[TransformationComp_Rotation], defRotation, maxTime, minTime, rotOrder);
     } else {
         for (size_t i = 0; i < keyCount; ++i) {
-            outRotations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outRotations[i].mTime = CONVERT_FBX_TIME(keytimes[i]);
             outRotations[i].mValue = defQuat;
         }
     }
@@ -3117,7 +3117,7 @@ aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name,
         InterpolateKeys(outScales, keytimes, keyframeLists[TransformationComp_Scaling], defScale, maxTime, minTime);
     } else {
         for (size_t i = 0; i < keyCount; ++i) {
-            outScales[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outScales[i].mTime = CONVERT_FBX_TIME(keytimes[i]);
             outScales[i].mValue = defScale;
         }
     }
@@ -3306,7 +3306,7 @@ void FBXConverter::InterpolateKeys(aiVectorKey *valOut, const KeyTimeList &keys,
         }
 
         // magic value to convert fbx times to seconds
-        valOut->mTime = CONVERT_FBX_TIME(time) * anim_fps;
+        valOut->mTime = CONVERT_FBX_TIME(time);
 
         min_time = std::min(min_time, valOut->mTime);
         max_time = std::max(max_time, valOut->mTime);

code/AssetLib/glTF2/glTF2Exporter.cpp

@@ -1258,9 +1258,6 @@ inline Ref<Accessor> GetSamplerInputRef(Asset& asset, std::string& animId, Ref<B
 inline void ExtractTranslationSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
 {
     const unsigned int numKeyframes = nodeChannel->mNumPositionKeys;
-    if (numKeyframes == 0) {
-        return;
-    }
 
     std::vector<float> times(numKeyframes);
     std::vector<float> values(numKeyframes * 3);
@@ -1281,9 +1278,6 @@ inline void ExtractTranslationSampler(Asset& asset, std::string& animId, Ref<Buf
 inline void ExtractScaleSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
 {
     const unsigned int numKeyframes = nodeChannel->mNumScalingKeys;
-    if (numKeyframes == 0) {
-        return;
-    }
 
     std::vector<float> times(numKeyframes);
     std::vector<float> values(numKeyframes * 3);
@@ -1304,9 +1298,6 @@ inline void ExtractScaleSampler(Asset& asset, std::string& animId, Ref<Buffer>&
 inline void ExtractRotationSampler(Asset& asset, std::string& animId, Ref<Buffer>& buffer, const aiNodeAnim* nodeChannel, float ticksPerSecond, Animation::Sampler& sampler)
 {
     const unsigned int numKeyframes = nodeChannel->mNumRotationKeys;
-    if (numKeyframes == 0) {
-        return;
-    }
 
     std::vector<float> times(numKeyframes);
     std::vector<float> values(numKeyframes * 4);
@@ -1347,30 +1338,37 @@ void glTF2Exporter::ExportAnimations()
         if (anim->mName.length > 0) {
             nameAnim = anim->mName.C_Str();
         }
+        Ref<Animation> animRef = mAsset->animations.Create(nameAnim);
 
         for (unsigned int channelIndex = 0; channelIndex < anim->mNumChannels; ++channelIndex) {
             const aiNodeAnim* nodeChannel = anim->mChannels[channelIndex];
 
-            // It appears that assimp stores this type of animation as multiple animations.
-            // where each aiNodeAnim in mChannels animates a specific node.
             std::string name = nameAnim + "_" + to_string(channelIndex);
             name = mAsset->FindUniqueID(name, "animation");
-            Ref<Animation> animRef = mAsset->animations.Create(name);
 
             Ref<Node> animNode = mAsset->nodes.Get(nodeChannel->mNodeName.C_Str());
 
+            if (nodeChannel->mNumPositionKeys > 0)
+            {
                 Animation::Sampler translationSampler;
                 ExtractTranslationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, translationSampler);
                 AddSampler(animRef, animNode, translationSampler, AnimationPath_TRANSLATION);
+            }
 
+            if (nodeChannel->mNumRotationKeys > 0)
+            {
                 Animation::Sampler rotationSampler;
                 ExtractRotationSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, rotationSampler);
                 AddSampler(animRef, animNode, rotationSampler, AnimationPath_ROTATION);
+            }
 
+            if (nodeChannel->mNumScalingKeys > 0)
+            {
                 Animation::Sampler scaleSampler;
                 ExtractScaleSampler(*mAsset, name, bufferRef, nodeChannel, ticksPerSecond, scaleSampler);
                 AddSampler(animRef, animNode, scaleSampler, AnimationPath_SCALE);
             }
+        }
 
         // Assimp documentation staes this is not used (not implemented)
         // for (unsigned int channelIndex = 0; channelIndex < anim->mNumMeshChannels; ++channelIndex) {

code/AssetLib/glTF2/glTF2Importer.cpp

@@ -229,6 +229,7 @@ inline void SetMaterialTextureProperty(std::vector<int> &embeddedTexIdxs, Asset
 static aiMaterial *ImportMaterial(std::vector<int> &embeddedTexIdxs, Asset &r, Material &mat) {
     aiMaterial *aimat = new aiMaterial();
 
+    try {
         if (!mat.name.empty()) {
             aiString str(mat.name);
 
@@ -282,6 +283,10 @@ static aiMaterial *ImportMaterial(std::vector<int> &embeddedTexIdxs, Asset &r, M
         }
 
         return aimat;
+    } catch (...) {
+        delete aimat;
+        throw;
+    }
 }
 
 void glTF2Importer::ImportMaterials(glTF2::Asset &r) {
@@ -291,6 +296,7 @@ void glTF2Importer::ImportMaterials(glTF2::Asset &r) {
 
     mScene->mNumMaterials = numImportedMaterials + 1;
     mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
+    std::fill(mScene->mMaterials, mScene->mMaterials + mScene->mNumMaterials, nullptr);
     mScene->mMaterials[numImportedMaterials] = ImportMaterial(embeddedTexIdxs, r, defaultMaterial);
 
     for (unsigned int i = 0; i < numImportedMaterials; ++i) {
@@ -452,6 +458,7 @@ void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
             if (targets.size() > 0) {
                 aim->mNumAnimMeshes = (unsigned int)targets.size();
                 aim->mAnimMeshes = new aiAnimMesh *[aim->mNumAnimMeshes];
+                std::fill(aim->mAnimMeshes, aim->mAnimMeshes + aim->mNumAnimMeshes, nullptr);
                 for (size_t i = 0; i < targets.size(); i++) {
                     bool needPositions = targets[i].position.size() > 0;
                     bool needNormals = targets[i].normal.size() > 0;
@@ -510,7 +517,9 @@ void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
                 size_t count = prim.indices->count;
 
                 Accessor::Indexer data = prim.indices->GetIndexer();
-                ai_assert(data.IsValid());
+                if (!data.IsValid()) {
+                    throw DeadlyImportError("GLTF: Invalid accessor without data in mesh ", getContextForErrorMessages(mesh.id, mesh.name));
+                }
 
                 switch (prim.mode) {
                     case PrimitiveMode_POINTS: {
@@ -699,6 +708,7 @@ void glTF2Importer::ImportCameras(glTF2::Asset &r) {
     ASSIMP_LOG_DEBUG_F("Importing ", numCameras, " cameras");
     mScene->mNumCameras = numCameras;
     mScene->mCameras = new aiCamera *[numCameras];
+    std::fill(mScene->mCameras, mScene->mCameras + numCameras, nullptr);
 
     for (size_t i = 0; i < numCameras; ++i) {
         Camera &cam = r.cameras[i];
@@ -735,6 +745,7 @@ void glTF2Importer::ImportLights(glTF2::Asset &r) {
     ASSIMP_LOG_DEBUG_F("Importing ", numLights, " lights");
     mScene->mNumLights = numLights;
     mScene->mLights = new aiLight *[numLights];
+    std::fill(mScene->mLights, mScene->mLights + numLights, nullptr);
 
     for (size_t i = 0; i < numLights; ++i) {
         Light &light = r.lights[i];
@@ -898,9 +909,11 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
 
     aiNode *ainode = new aiNode(GetNodeName(node));
 
+    try {
         if (!node.children.empty()) {
             ainode->mNumChildren = unsigned(node.children.size());
             ainode->mChildren = new aiNode *[ainode->mNumChildren];
+            std::fill(ainode->mChildren, ainode->mChildren + ainode->mNumChildren, nullptr);
 
             for (unsigned int i = 0; i < ainode->mNumChildren; ++i) {
                 aiNode *child = ImportNode(pScene, r, meshOffsets, node.children[i]);
@@ -938,6 +951,7 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
 
                     mesh->mNumBones = static_cast<unsigned int>(numBones);
                     mesh->mBones = new aiBone *[mesh->mNumBones];
+                    std::fill(mesh->mBones, mesh->mBones + mesh->mNumBones, nullptr);
 
                     // GLTF and Assimp choose to store bone weights differently.
                     // GLTF has each vertex specify which bones influence the vertex.
@@ -1021,6 +1035,10 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
         }
 
         return ainode;
+    } catch (...) {
+        delete ainode;
+        throw;
+    }
 }
 
 void glTF2Importer::ImportNodes(glTF2::Asset &r) {
@@ -1036,14 +1054,16 @@ void glTF2Importer::ImportNodes(glTF2::Asset &r) {
     if (numRootNodes == 1) { // a single root node: use it
         mScene->mRootNode = ImportNode(mScene, r, meshOffsets, rootNodes[0]);
     } else if (numRootNodes > 1) { // more than one root node: create a fake root
-        aiNode *root = new aiNode("ROOT");
+        aiNode *root = mScene->mRootNode = new aiNode("ROOT");
+
         root->mChildren = new aiNode *[numRootNodes];
+        std::fill(root->mChildren, root->mChildren + numRootNodes, nullptr);
+
         for (unsigned int i = 0; i < numRootNodes; ++i) {
             aiNode *node = ImportNode(mScene, r, meshOffsets, rootNodes[i]);
             node->mParent = root;
             root->mChildren[root->mNumChildren++] = node;
         }
-        mScene->mRootNode = root;
     } else {
         mScene->mRootNode = new aiNode("ROOT");
     }
@@ -1066,6 +1086,8 @@ struct AnimationSamplers {
 
 aiNodeAnim *CreateNodeAnim(glTF2::Asset&, Node &node, AnimationSamplers &samplers) {
     aiNodeAnim *anim = new aiNodeAnim();
+
+    try {
         anim->mNodeName = GetNodeName(node);
 
         static const float kMillisecondsFromSeconds = 1000.f;
@@ -1147,10 +1169,16 @@ aiNodeAnim *CreateNodeAnim(glTF2::Asset&, Node &node, AnimationSamplers &sampler
         }
 
         return anim;
+    } catch (...) {
+        delete anim;
+        throw;
+    }
 }
 
 aiMeshMorphAnim *CreateMeshMorphAnim(glTF2::Asset&, Node &node, AnimationSamplers &samplers) {
     aiMeshMorphAnim *anim = new aiMeshMorphAnim();
+
+    try {
         anim->mName = GetNodeName(node);
 
         static const float kMillisecondsFromSeconds = 1000.f;
@@ -1186,13 +1214,17 @@ aiMeshMorphAnim *CreateMeshMorphAnim(glTF2::Asset&, Node &node, AnimationSampler
         }
 
         return anim;
+    } catch (...) {
+        delete anim;
+        throw;
+    }
 }
 
 std::unordered_map<unsigned int, AnimationSamplers> GatherSamplers(Animation &anim) {
     std::unordered_map<unsigned int, AnimationSamplers> samplers;
     for (unsigned int c = 0; c < anim.channels.size(); ++c) {
         Animation::Channel &channel = anim.channels[c];
-        if (channel.sampler >= static_cast<int>(anim.samplers.size())) {
+        if (channel.sampler < 0 || channel.sampler >= static_cast<int>(anim.samplers.size())) {
             continue;
         }
 
@@ -1224,10 +1256,13 @@ void glTF2Importer::ImportAnimations(glTF2::Asset &r) {
     }
 
     mScene->mAnimations = new aiAnimation *[numAnimations];
+    std::fill(mScene->mAnimations, mScene->mAnimations + numAnimations, nullptr);
+
     for (unsigned int i = 0; i < numAnimations; ++i) {
+        aiAnimation *ai_anim = mScene->mAnimations[i] = new aiAnimation();
+
         Animation &anim = r.animations[i];
 
-        aiAnimation *ai_anim = new aiAnimation();
         ai_anim->mName = anim.name;
         ai_anim->mDuration = 0;
         ai_anim->mTicksPerSecond = 0;
@@ -1249,6 +1284,7 @@ void glTF2Importer::ImportAnimations(glTF2::Asset &r) {
         ai_anim->mNumChannels = numChannels;
         if (ai_anim->mNumChannels > 0) {
             ai_anim->mChannels = new aiNodeAnim *[ai_anim->mNumChannels];
+            std::fill(ai_anim->mChannels, ai_anim->mChannels + ai_anim->mNumChannels, nullptr);
             int j = 0;
             for (auto &iter : samplers) {
                 if ((nullptr != iter.second.rotation) || (nullptr != iter.second.scale) || (nullptr != iter.second.translation)) {
@@ -1261,6 +1297,7 @@ void glTF2Importer::ImportAnimations(glTF2::Asset &r) {
         ai_anim->mNumMorphMeshChannels = numMorphMeshChannels;
         if (ai_anim->mNumMorphMeshChannels > 0) {
             ai_anim->mMorphMeshChannels = new aiMeshMorphAnim *[ai_anim->mNumMorphMeshChannels];
+            std::fill(ai_anim->mMorphMeshChannels, ai_anim->mMorphMeshChannels + ai_anim->mNumMorphMeshChannels, nullptr);
             int j = 0;
             for (auto &iter : samplers) {
                 if (nullptr != iter.second.weight) {
@@ -1312,8 +1349,6 @@ void glTF2Importer::ImportAnimations(glTF2::Asset &r) {
 
         ai_anim->mDuration = maxDuration;
         ai_anim->mTicksPerSecond = 1000.0;
-
-        mScene->mAnimations[i] = ai_anim;
     }
 }
 
@@ -1333,6 +1368,7 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
       ASSIMP_LOG_DEBUG_F("Importing ", numEmbeddedTexs, " embedded textures");
 
     mScene->mTextures = new aiTexture *[numEmbeddedTexs];
+    std::fill(mScene->mTextures, mScene->mTextures + numEmbeddedTexs, nullptr);
 
     // Add the embedded textures
     for (size_t i = 0; i < r.images.Size(); ++i) {

code/CMakeLists.txt

@@ -1015,7 +1015,7 @@ ENDIF()
 # RT-extensions is used in "contrib/Open3DGC/o3dgcTimer.h" for collecting statistics. Pointed file
 # has implementation for different platforms: WIN32, __MACH__ and other ("else" block).
 FIND_PACKAGE(RT QUIET)
-IF (NOT ASSIMP_HUNTER_ENABLED AND (RT_FOUND OR MSVC))
+IF (NOT ASSIMP_HUNTER_ENABLED AND (RT_FOUND OR WIN32))
   SET( ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC 1 )
   ADD_DEFINITIONS( -DASSIMP_IMPORTER_GLTF_USE_OPEN3DGC=1 )
 ELSE ()

code/Common/SceneCombiner.cpp

@@ -183,9 +183,10 @@ void SceneCombiner::MergeScenes(aiScene **_dest, std::vector<aiScene *> &src, un
             *_dest = src[0];
         return;
     }
-    if (*_dest)
+    if (*_dest) {
         (*_dest)->~aiScene();
-    else
+        new (*_dest) aiScene();
+    } else
         *_dest = new aiScene();
 
     // Create a dummy scene to serve as master for the others

code/Common/ZipArchiveIOSystem.cpp

@@ -146,7 +146,7 @@ int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) {
 zlib_filefunc_def IOSystem2Unzip::get(IOSystem *pIOHandler) {
     zlib_filefunc_def mapping;
 
-#ifdef ASSIMP_USE_HUNTER
+#if defined (ASSIMP_USE_HUNTER) || defined (__MINGW32__) // GH#3144
     mapping.zopen_file = (open_file_func)open;
     mapping.zread_file = (read_file_func)read;
     mapping.zwrite_file = (write_file_func)write;

code/PostProcessing/SortByPTypeProcess.cpp

@@ -243,6 +243,45 @@ void SortByPTypeProcess::Execute(aiScene *pScene) {
                 }
             }
 
+            if (mesh->mNumAnimMeshes > 0 && mesh->mAnimMeshes) {
+                out->mNumAnimMeshes = mesh->mNumAnimMeshes;
+                out->mAnimMeshes = new aiAnimMesh *[out->mNumAnimMeshes];
+            }
+
+            for (unsigned int j = 0; j < mesh->mNumAnimMeshes; ++j) {
+                aiAnimMesh *animMesh = mesh->mAnimMeshes[j];
+                aiAnimMesh *outAnimMesh = out->mAnimMeshes[j] = new aiAnimMesh;
+                outAnimMesh->mNumVertices = out->mNumVertices;
+                if (animMesh->mVertices)
+                    outAnimMesh->mVertices = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mVertices = nullptr;
+                if (animMesh->mNormals)
+                    outAnimMesh->mNormals = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mNormals = nullptr;
+                if (animMesh->mTangents)
+                    outAnimMesh->mTangents = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mTangents = nullptr;
+                if (animMesh->mBitangents)
+                    outAnimMesh->mBitangents = new aiVector3D[out->mNumVertices];
+                else
+                    outAnimMesh->mBitangents = nullptr;
+                for (int jj = 0; jj < AI_MAX_NUMBER_OF_COLOR_SETS; ++jj) {
+                    if (animMesh->mColors[jj])
+                        outAnimMesh->mColors[jj] = new aiColor4D[out->mNumVertices];
+                    else
+                        outAnimMesh->mColors[jj] = nullptr;
+                }
+                for (int jj = 0; jj < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++jj) {
+                    if (animMesh->mTextureCoords[jj])
+                        outAnimMesh->mTextureCoords[jj] = new aiVector3D[out->mNumVertices];
+                    else
+                        outAnimMesh->mTextureCoords[jj] = nullptr;
+                }
+            }
+
             typedef std::vector<aiVertexWeight> TempBoneInfo;
             std::vector<TempBoneInfo> tempBones(mesh->mNumBones);
 
@@ -252,6 +291,7 @@ void SortByPTypeProcess::Execute(aiScene *pScene) {
             }
 
             unsigned int outIdx = 0;
+            unsigned int amIdx = 0; // AnimMesh index
             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)) {
@@ -293,6 +333,30 @@ void SortByPTypeProcess::Execute(aiScene *pScene) {
                         *cols[pp]++ = mesh->mColors[pp][idx];
                     }
 
+                    unsigned int pp = 0;
+                    for (; pp < mesh->mNumAnimMeshes; ++pp) {
+                        aiAnimMesh *animMesh = mesh->mAnimMeshes[pp];
+                        aiAnimMesh *outAnimMesh = out->mAnimMeshes[pp];
+                        if (animMesh->mVertices)
+                            outAnimMesh->mVertices[amIdx] = animMesh->mVertices[idx];
+                        if (animMesh->mNormals)
+                            outAnimMesh->mNormals[amIdx] = animMesh->mNormals[idx];
+                        if (animMesh->mTangents)
+                            outAnimMesh->mTangents[amIdx] = animMesh->mTangents[idx];
+                        if (animMesh->mBitangents)
+                            outAnimMesh->mBitangents[amIdx] = animMesh->mBitangents[idx];
+                        for (int jj = 0; jj < AI_MAX_NUMBER_OF_COLOR_SETS; ++jj) {
+                            if (animMesh->mColors[jj])
+                                outAnimMesh->mColors[jj][amIdx] = animMesh->mColors[jj][idx];
+                        }
+                        for (int jj = 0; jj < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++jj) {
+                            if (animMesh->mTextureCoords[jj])
+                                outAnimMesh->mTextureCoords[jj][amIdx] = animMesh->mTextureCoords[jj][idx];
+                        }
+                    }
+                    if (pp == mesh->mNumAnimMeshes)
+                        amIdx++;
+
                     in.mIndices[q] = outIdx++;
                 }
 

contrib/Open3DGC/o3dgcVector.inl

@@ -175,7 +175,7 @@ namespace o3dgc
         m_data[2] = rhs.m_data[2];
     }
     template <typename T>
-    inline Vec3<T>::~Vec3(void){};
+    inline Vec3<T>::~Vec3(void){}
 
     template <typename T>
     inline Vec3<T>::Vec3() {}
@@ -308,7 +308,7 @@ namespace o3dgc
         m_data[1] = rhs.m_data[1];
     }
     template <typename T>
-    inline Vec2<T>::~Vec2(void){};
+    inline Vec2<T>::~Vec2(void){}
 
     template <typename T>
     inline Vec2<T>::Vec2() {}

samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp

@@ -763,7 +763,7 @@ void cleanup()
 
 	if (g_hWnd)
 		KillGLWindow();
-};
+}
 
 LRESULT CALLBACK WndProc(HWND hWnd,				// Handles for this Window
 						 UINT uMsg,				// Message for this Window

tools/assimp_view/MeshRenderer.cpp

@@ -161,4 +161,4 @@ int CMeshRenderer::DrawSorted(unsigned int iIndex,const aiMatrix4x4& mWorld) {
 
     return 1;
 }
-};
+}

tools/assimp_view/MessageProc.cpp

@@ -2143,7 +2143,7 @@ INT_PTR CALLBACK AboutMessageProc(HWND hwndDlg,UINT uMsg,
         }
     return FALSE;
     }
-};
+}
 
 using namespace AssimpView;