move 3rd-party librarys into libs/ and add built-in honeysuckle

2 files changed, 802 insertions, 0 deletions

diff --git a/libs/assimp/code/AssetLib/MS3D/MS3DLoader.cpp b/libs/assimp/code/AssetLib/MS3D/MS3DLoader.cpp
new file mode 100644
index 0000000..fc2ed04
--- /dev/null
+++ b/libs/assimp/code/AssetLib/MS3D/MS3DLoader.cpp
@@ -0,0 +1,656 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, 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  MS3DLoader.cpp
+ *  @brief Implementation of the Ms3D importer class.
+ *  Written against http://chumbalum.swissquake.ch/ms3d/ms3dspec.txt
+ */
+
+
+#ifndef ASSIMP_BUILD_NO_MS3D_IMPORTER
+
+// internal headers
+#include "MS3DLoader.h"
+#include <assimp/StreamReader.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/scene.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/importerdesc.h>
+#include <map>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+    "Milkshape 3D Importer",
+    "",
+    "",
+    "http://chumbalum.swissquake.ch/",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "ms3d"
+};
+
+// ASSIMP_BUILD_MS3D_ONE_NODE_PER_MESH
+//   (enable old code path, which generates extra nodes per mesh while
+//    the newer code uses aiMesh::mName to express the name of the
+//    meshes (a.k.a. groups in MS3D))
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+MS3DImporter::MS3DImporter()
+    : mScene()
+{}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+MS3DImporter::~MS3DImporter()
+{}
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool MS3DImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool /*checkSig*/) const
+{
+    static const char* tokens[] = { "MS3D000000" };
+    return SearchFileHeaderForToken(pIOHandler,pFile,tokens,AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc* MS3DImporter::GetInfo () const
+{
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ReadColor(StreamReaderLE& stream, aiColor4D& ambient)
+{
+    // aiColor4D is packed on gcc, implicit binding to float& fails therefore.
+    stream >> (float&)ambient.r >> (float&)ambient.g >> (float&)ambient.b >> (float&)ambient.a;
+}
+
+// ------------------------------------------------------------------------------------------------
+void ReadVector(StreamReaderLE& stream, aiVector3D& pos)
+{
+    // See note in ReadColor()
+    stream >> (float&)pos.x >> (float&)pos.y >> (float&)pos.z;
+}
+
+// ------------------------------------------------------------------------------------------------
+template<typename T>
+void MS3DImporter :: ReadComments(StreamReaderLE& stream, std::vector<T>& outp)
+{
+    uint16_t cnt;
+    stream >> cnt;
+
+    for(unsigned int i = 0; i < cnt; ++i) {
+        uint32_t index, clength;
+        stream >> index >> clength;
+
+        if(index >= outp.size()) {
+            ASSIMP_LOG_WARN("MS3D: Invalid index in comment section");
+        }
+        else if (clength > stream.GetRemainingSize()) {
+            throw DeadlyImportError("MS3D: Failure reading comment, length field is out of range");
+        }
+        else {
+            outp[index].comment = std::string(reinterpret_cast<char*>(stream.GetPtr()),clength);
+        }
+        stream.IncPtr(clength);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename T, typename T2, typename T3> bool inrange(const T& in, const T2& lower, const T3& higher)
+{
+    return in > lower && in <= higher;
+}
+
+// ------------------------------------------------------------------------------------------------
+void MS3DImporter :: CollectChildJoints(const std::vector<TempJoint>& joints,
+    std::vector<bool>& hadit,
+    aiNode* nd,
+    const aiMatrix4x4& absTrafo)
+{
+    unsigned int cnt = 0;
+    for(size_t i = 0; i < joints.size(); ++i) {
+        if (!hadit[i] && !strcmp(joints[i].parentName,nd->mName.data)) {
+            ++cnt;
+        }
+    }
+
+    nd->mChildren = new aiNode*[nd->mNumChildren = cnt];
+    cnt = 0;
+    for(size_t i = 0; i < joints.size(); ++i) {
+        if (!hadit[i] && !strcmp(joints[i].parentName,nd->mName.data)) {
+            aiNode* ch = nd->mChildren[cnt++] = new aiNode(joints[i].name);
+            ch->mParent = nd;
+
+            ch->mTransformation = aiMatrix4x4::Translation(joints[i].position,aiMatrix4x4()=aiMatrix4x4())*
+                aiMatrix4x4().FromEulerAnglesXYZ(joints[i].rotation);
+
+            const aiMatrix4x4 abs = absTrafo*ch->mTransformation;
+            for(unsigned int a = 0; a < mScene->mNumMeshes; ++a) {
+                aiMesh* const msh = mScene->mMeshes[a];
+                for(unsigned int n = 0; n < msh->mNumBones; ++n) {
+                    aiBone* const bone = msh->mBones[n];
+
+                    if(bone->mName == ch->mName) {
+                        bone->mOffsetMatrix = aiMatrix4x4(abs).Inverse();
+                    }
+                }
+            }
+
+            hadit[i] = true;
+            CollectChildJoints(joints,hadit,ch,abs);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void MS3DImporter :: CollectChildJoints(const std::vector<TempJoint>& joints, aiNode* nd)
+{
+     std::vector<bool> hadit(joints.size(),false);
+     aiMatrix4x4 trafo;
+
+     CollectChildJoints(joints,hadit,nd,trafo);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void MS3DImporter::InternReadFile( const std::string& pFile,
+    aiScene* pScene, IOSystem* pIOHandler)
+{
+
+    auto file = pIOHandler->Open(pFile, "rb");
+    if (!file)
+        throw DeadlyImportError("MS3D: Could not open ", pFile);
+
+    StreamReaderLE stream(file);
+
+    // CanRead() should have done this already
+    char head[10];
+    int32_t version;
+
+    mScene = pScene;
+
+
+    // 1 ------------ read into temporary data structures mirroring the original file
+
+    stream.CopyAndAdvance(head,10);
+    stream >> version;
+    if (strncmp(head,"MS3D000000",10)) {
+        throw DeadlyImportError("Not a MS3D file, magic string MS3D000000 not found: ", pFile);
+    }
+
+    if (version != 4) {
+        throw DeadlyImportError("MS3D: Unsupported file format version, 4 was expected");
+    }
+
+    uint16_t verts;
+    stream >> verts;
+
+    std::vector<TempVertex> vertices(verts);
+    for (unsigned int i = 0; i < verts; ++i) {
+        TempVertex& v = vertices[i];
+
+        stream.IncPtr(1);
+        ReadVector(stream,v.pos);
+        v.bone_id[0] = stream.GetI1();
+        v.ref_cnt = stream.GetI1();
+
+        v.bone_id[1] = v.bone_id[2] = v.bone_id[3] = UINT_MAX;
+        v.weights[1] = v.weights[2] = v.weights[3] = 0.f;
+        v.weights[0] = 1.f;
+    }
+
+    uint16_t tris;
+    stream >> tris;
+
+    std::vector<TempTriangle> triangles(tris);
+    for (unsigned int i = 0;i < tris; ++i) {
+        TempTriangle& t = triangles[i];
+
+        stream.IncPtr(2);
+        for (unsigned int j = 0; j < 3; ++j) {
+            t.indices[j] = stream.GetI2();
+        }
+
+        for (unsigned int j = 0; j < 3; ++j) {
+            ReadVector(stream,t.normals[j]);
+        }
+
+        for (unsigned int j = 0; j < 3; ++j) {
+            stream >> (float&)(t.uv[j].x); // see note in ReadColor()
+        }
+        for (unsigned int j = 0; j < 3; ++j) {
+            stream >> (float&)(t.uv[j].y);
+        }
+
+        t.sg    = stream.GetI1();
+        t.group = stream.GetI1();
+    }
+
+    uint16_t grp;
+    stream >> grp;
+
+    bool need_default = false;
+    std::vector<TempGroup> groups(grp);
+    for (unsigned int i = 0;i < grp; ++i) {
+        TempGroup& t = groups[i];
+
+        stream.IncPtr(1);
+        stream.CopyAndAdvance(t.name,32);
+
+        t.name[32] = '\0';
+        uint16_t num;
+        stream >> num;
+
+        t.triangles.resize(num);
+        for (unsigned int j = 0; j < num; ++j) {
+            t.triangles[j] = stream.GetI2();
+        }
+        t.mat = stream.GetI1();
+        if (t.mat == UINT_MAX) {
+            need_default = true;
+        }
+    }
+
+    uint16_t mat;
+    stream >> mat;
+
+    std::vector<TempMaterial> materials(mat);
+    for (unsigned int j = 0;j < mat; ++j) {
+        TempMaterial& t = materials[j];
+
+        stream.CopyAndAdvance(t.name,32);
+        t.name[32] = '\0';
+
+        ReadColor(stream,t.ambient);
+        ReadColor(stream,t.diffuse);
+        ReadColor(stream,t.specular);
+        ReadColor(stream,t.emissive);
+        stream >> t.shininess  >> t.transparency;
+
+        stream.IncPtr(1);
+
+        stream.CopyAndAdvance(t.texture,128);
+        t.texture[128] = '\0';
+
+        stream.CopyAndAdvance(t.alphamap,128);
+        t.alphamap[128] = '\0';
+    }
+
+    float animfps, currenttime;
+    uint32_t totalframes;
+    stream >> animfps >> currenttime >> totalframes;
+
+    uint16_t joint;
+    stream >> joint;
+
+    std::vector<TempJoint> joints(joint);
+    for(unsigned int ii = 0; ii < joint; ++ii) {
+        TempJoint& j = joints[ii];
+
+        stream.IncPtr(1);
+        stream.CopyAndAdvance(j.name,32);
+        j.name[32] = '\0';
+
+        stream.CopyAndAdvance(j.parentName,32);
+        j.parentName[32] = '\0';
+
+        ReadVector(stream,j.rotation);
+        ReadVector(stream,j.position);
+
+        j.rotFrames.resize(stream.GetI2());
+        j.posFrames.resize(stream.GetI2());
+
+        for(unsigned int a = 0; a < j.rotFrames.size(); ++a) {
+            TempKeyFrame& kf = j.rotFrames[a];
+            stream >> kf.time;
+            ReadVector(stream,kf.value);
+        }
+        for(unsigned int a = 0; a < j.posFrames.size(); ++a) {
+            TempKeyFrame& kf = j.posFrames[a];
+            stream >> kf.time;
+            ReadVector(stream,kf.value);
+        }
+    }
+
+    if(stream.GetRemainingSize() > 4) {
+        uint32_t subversion;
+        stream >> subversion;
+        if (subversion == 1) {
+            ReadComments<TempGroup>(stream,groups);
+            ReadComments<TempMaterial>(stream,materials);
+            ReadComments<TempJoint>(stream,joints);
+
+            // model comment - print it for we have such a nice log.
+            if (stream.GetI4()) {
+                const size_t len = static_cast<size_t>(stream.GetI4());
+                if (len > stream.GetRemainingSize()) {
+                    throw DeadlyImportError("MS3D: Model comment is too long");
+                }
+
+                const std::string& s = std::string(reinterpret_cast<char*>(stream.GetPtr()),len);
+                ASSIMP_LOG_DEBUG("MS3D: Model comment: ", s);
+            }
+
+            if(stream.GetRemainingSize() > 4 && inrange((stream >> subversion,subversion),1u,3u)) {
+                for(unsigned int i = 0; i < verts; ++i) {
+                    TempVertex& v = vertices[i];
+                    v.weights[3]=1.f;
+                    for(unsigned int n = 0; n < 3; v.weights[3]-=v.weights[n++]) {
+                        v.bone_id[n+1] = stream.GetI1();
+                        v.weights[n] = static_cast<float>(static_cast<unsigned int>(stream.GetI1()))/255.f;
+                    }
+                    stream.IncPtr((subversion-1)<<2u);
+                }
+
+                // even further extra data is not of interest for us, at least now now.
+            }
+        }
+    }
+
+    // 2 ------------ convert to proper aiXX data structures -----------------------------------
+
+    if (need_default && materials.size()) {
+        ASSIMP_LOG_WARN("MS3D: Found group with no material assigned, spawning default material");
+        // if one of the groups has no material assigned, but there are other
+        // groups with materials, a default material needs to be added (
+        // scenepreprocessor adds a default material only if nummat==0).
+        materials.push_back(TempMaterial());
+        TempMaterial& m = materials.back();
+
+        strcpy(m.name,"<MS3D_DefaultMat>");
+        m.diffuse = aiColor4D(0.6f,0.6f,0.6f,1.0);
+        m.transparency = 1.f;
+        m.shininess = 0.f;
+
+        // this is because these TempXXX struct's have no c'tors.
+        m.texture[0] = m.alphamap[0] = '\0';
+
+        for (unsigned int i = 0; i < groups.size(); ++i) {
+            TempGroup& g = groups[i];
+            if (g.mat == UINT_MAX) {
+                g.mat = static_cast<unsigned int>(materials.size()-1);
+            }
+        }
+    }
+
+    // convert materials to our generic key-value dict-alike
+    if (materials.size()) {
+        pScene->mMaterials = new aiMaterial*[materials.size()];
+        for (size_t i = 0; i < materials.size(); ++i) {
+
+            aiMaterial* mo = new aiMaterial();
+            pScene->mMaterials[pScene->mNumMaterials++] = mo;
+
+            const TempMaterial& mi = materials[i];
+
+            aiString tmp;
+            if (0[mi.alphamap]) {
+                tmp = aiString(mi.alphamap);
+                mo->AddProperty(&tmp,AI_MATKEY_TEXTURE_OPACITY(0));
+            }
+            if (0[mi.texture]) {
+                tmp = aiString(mi.texture);
+                mo->AddProperty(&tmp,AI_MATKEY_TEXTURE_DIFFUSE(0));
+            }
+            if (0[mi.name]) {
+                tmp = aiString(mi.name);
+                mo->AddProperty(&tmp,AI_MATKEY_NAME);
+            }
+
+            mo->AddProperty(&mi.ambient,1,AI_MATKEY_COLOR_AMBIENT);
+            mo->AddProperty(&mi.diffuse,1,AI_MATKEY_COLOR_DIFFUSE);
+            mo->AddProperty(&mi.specular,1,AI_MATKEY_COLOR_SPECULAR);
+            mo->AddProperty(&mi.emissive,1,AI_MATKEY_COLOR_EMISSIVE);
+
+            mo->AddProperty(&mi.shininess,1,AI_MATKEY_SHININESS);
+            mo->AddProperty(&mi.transparency,1,AI_MATKEY_OPACITY);
+
+            const int sm = mi.shininess>0.f?aiShadingMode_Phong:aiShadingMode_Gouraud;
+            mo->AddProperty(&sm,1,AI_MATKEY_SHADING_MODEL);
+        }
+    }
+
+    // convert groups to meshes
+    if (groups.empty()) {
+        throw DeadlyImportError("MS3D: Didn't get any group records, file is malformed");
+    }
+
+    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes=static_cast<unsigned int>(groups.size())]();
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+
+        aiMesh* m = pScene->mMeshes[i] = new aiMesh();
+        const TempGroup& g = groups[i];
+
+        if (pScene->mNumMaterials && g.mat > pScene->mNumMaterials) {
+            throw DeadlyImportError("MS3D: Encountered invalid material index, file is malformed");
+        } // no error if no materials at all - scenepreprocessor adds one then
+
+        m->mMaterialIndex  = g.mat;
+        m->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+        m->mFaces = new aiFace[m->mNumFaces = static_cast<unsigned int>(g.triangles.size())];
+        m->mNumVertices = m->mNumFaces*3;
+
+        // storage for vertices - verbose format, as requested by the postprocessing pipeline
+        m->mVertices = new aiVector3D[m->mNumVertices];
+        m->mNormals  = new aiVector3D[m->mNumVertices];
+        m->mTextureCoords[0] = new aiVector3D[m->mNumVertices];
+        m->mNumUVComponents[0] = 2;
+
+        typedef std::map<unsigned int,unsigned int> BoneSet;
+        BoneSet mybones;
+
+        for (unsigned int j = 0,n = 0; j < m->mNumFaces; ++j) {
+            aiFace& f = m->mFaces[j];
+            if (g.triangles[j]>triangles.size()) {
+                throw DeadlyImportError("MS3D: Encountered invalid triangle index, file is malformed");
+            }
+
+            TempTriangle& t = triangles[g.triangles[j]];
+            f.mIndices = new unsigned int[f.mNumIndices=3];
+
+            for (unsigned int k = 0; k < 3; ++k,++n) {
+                if (t.indices[k]>vertices.size()) {
+                    throw DeadlyImportError("MS3D: Encountered invalid vertex index, file is malformed");
+                }
+
+                const TempVertex& v = vertices[t.indices[k]];
+                for(unsigned int a = 0; a < 4; ++a) {
+                    if (v.bone_id[a] != UINT_MAX) {
+                        if (v.bone_id[a] >= joints.size()) {
+                            throw DeadlyImportError("MS3D: Encountered invalid bone index, file is malformed");
+                        }
+                        if (mybones.find(v.bone_id[a]) == mybones.end()) {
+                             mybones[v.bone_id[a]] = 1;
+                        }
+                        else ++mybones[v.bone_id[a]];
+                    }
+                }
+
+                // collect vertex components
+                m->mVertices[n] = v.pos;
+
+                m->mNormals[n] = t.normals[k];
+                m->mTextureCoords[0][n] = aiVector3D(t.uv[k].x,1.f-t.uv[k].y,0.0);
+                f.mIndices[k] = n;
+            }
+        }
+
+        // allocate storage for bones
+        if(!mybones.empty()) {
+            std::vector<unsigned int> bmap(joints.size());
+            m->mBones = new aiBone*[mybones.size()]();
+            for(BoneSet::const_iterator it = mybones.begin(); it != mybones.end(); ++it) {
+                aiBone* const bn = m->mBones[m->mNumBones] = new aiBone();
+                const TempJoint& jnt = joints[(*it).first];
+
+                bn->mName.Set(jnt.name);
+                bn->mWeights = new aiVertexWeight[(*it).second];
+
+                bmap[(*it).first] = m->mNumBones++;
+            }
+
+            // .. and collect bone weights
+            for (unsigned int j = 0,n = 0; j < m->mNumFaces; ++j) {
+                TempTriangle& t = triangles[g.triangles[j]];
+
+                for (unsigned int k = 0; k < 3; ++k,++n) {
+                    const TempVertex& v = vertices[t.indices[k]];
+                    for(unsigned int a = 0; a < 4; ++a) {
+                        const unsigned int bone = v.bone_id[a];
+                        if(bone==UINT_MAX){
+                            continue;
+                        }
+
+                        aiBone* const outbone = m->mBones[bmap[bone]];
+                        aiVertexWeight& outwght = outbone->mWeights[outbone->mNumWeights++];
+
+                        outwght.mVertexId = n;
+                        outwght.mWeight = v.weights[a];
+                    }
+                }
+            }
+        }
+    }
+
+    // ... add dummy nodes under a single root, each holding a reference to one
+    // mesh. If we didn't do this, we'd lose the group name.
+    aiNode* rt = pScene->mRootNode = new aiNode("<MS3DRoot>");
+
+#ifdef ASSIMP_BUILD_MS3D_ONE_NODE_PER_MESH
+    rt->mChildren = new aiNode*[rt->mNumChildren=pScene->mNumMeshes+(joints.size()?1:0)]();
+
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        aiNode* nd = rt->mChildren[i] = new aiNode();
+
+        const TempGroup& g = groups[i];
+
+        // we need to generate an unique name for all mesh nodes.
+        // since we want to keep the group name, a prefix is
+        // prepended.
+        nd->mName = aiString("<MS3DMesh>_");
+        nd->mName.Append(g.name);
+        nd->mParent = rt;
+
+        nd->mMeshes = new unsigned int[nd->mNumMeshes = 1];
+        nd->mMeshes[0] = i;
+    }
+#else
+    rt->mMeshes = new unsigned int[pScene->mNumMeshes];
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        rt->mMeshes[rt->mNumMeshes++] = i;
+    }
+#endif
+
+    // convert animations as well
+    if(joints.size()) {
+#ifndef ASSIMP_BUILD_MS3D_ONE_NODE_PER_MESH
+        rt->mChildren = new aiNode*[1]();
+        rt->mNumChildren = 1;
+
+        aiNode* jt = rt->mChildren[0] = new aiNode();
+#else
+        aiNode* jt = rt->mChildren[pScene->mNumMeshes] = new aiNode();
+#endif
+        jt->mParent = rt;
+        CollectChildJoints(joints,jt);
+        jt->mName.Set("<MS3DJointRoot>");
+
+        pScene->mAnimations = new aiAnimation*[ pScene->mNumAnimations = 1 ];
+        aiAnimation* const anim = pScene->mAnimations[0] = new aiAnimation();
+
+        anim->mName.Set("<MS3DMasterAnim>");
+
+        // carry the fps info to the user by scaling all times with it
+        anim->mTicksPerSecond = animfps;
+
+        // leave duration at its default, so ScenePreprocessor will fill an appropriate
+        // value (the values taken from some MS3D files seem to be too unreliable
+        // to pass the validation)
+        // anim->mDuration = totalframes/animfps;
+
+        anim->mChannels = new aiNodeAnim*[joints.size()]();
+        for(std::vector<TempJoint>::const_iterator it = joints.begin(); it != joints.end(); ++it) {
+            if ((*it).rotFrames.empty() && (*it).posFrames.empty()) {
+                continue;
+            }
+
+            aiNodeAnim* nd = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
+            nd->mNodeName.Set((*it).name);
+
+            if ((*it).rotFrames.size()) {
+                nd->mRotationKeys = new aiQuatKey[(*it).rotFrames.size()];
+                for(std::vector<TempKeyFrame>::const_iterator rot = (*it).rotFrames.begin(); rot != (*it).rotFrames.end(); ++rot) {
+                    aiQuatKey& q = nd->mRotationKeys[nd->mNumRotationKeys++];
+
+                    q.mTime = (*rot).time*animfps;
+                    q.mValue = aiQuaternion(aiMatrix3x3(aiMatrix4x4().FromEulerAnglesXYZ((*it).rotation)*
+                        aiMatrix4x4().FromEulerAnglesXYZ((*rot).value)));
+                }
+            }
+
+            if ((*it).posFrames.size()) {
+                nd->mPositionKeys = new aiVectorKey[(*it).posFrames.size()];
+
+                aiQuatKey* qu = nd->mRotationKeys;
+                for(std::vector<TempKeyFrame>::const_iterator pos = (*it).posFrames.begin(); pos != (*it).posFrames.end(); ++pos,++qu) {
+                    aiVectorKey& v = nd->mPositionKeys[nd->mNumPositionKeys++];
+
+                    v.mTime = (*pos).time*animfps;
+                    v.mValue = (*it).position + (*pos).value;
+                }
+            }
+        }
+        // fixup to pass the validation if not a single animation channel is non-trivial
+        if (!anim->mNumChannels) {
+            anim->mChannels = nullptr;
+        }
+    }
+}
+
+#endif
diff --git a/libs/assimp/code/AssetLib/MS3D/MS3DLoader.h b/libs/assimp/code/AssetLib/MS3D/MS3DLoader.h
new file mode 100644
index 0000000..4bd4175
--- /dev/null
+++ b/libs/assimp/code/AssetLib/MS3D/MS3DLoader.h
@@ -0,0 +1,146 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2022, 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  MS3DLoader.h
+ *  @brief Declaration of the MS3D importer class.
+ */
+#pragma once
+#ifndef AI_MS3DLOADER_H_INCLUDED
+#define AI_MS3DLOADER_H_INCLUDED
+
+#include <assimp/BaseImporter.h>
+#include <assimp/StreamReader.h>
+struct aiNode;
+
+namespace Assimp {
+
+// ----------------------------------------------------------------------------------------------
+/** Milkshape 3D importer implementation */
+// ----------------------------------------------------------------------------------------------
+class MS3DImporter : public BaseImporter {
+public:
+    MS3DImporter();
+    ~MS3DImporter() override;
+
+    // -------------------------------------------------------------------
+    /** Returns whether the class can handle the format of the given file.
+    * See BaseImporter::CanRead() for details.  */
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
+
+protected:
+    // -------------------------------------------------------------------
+    /** Return importer meta information.
+     * See #BaseImporter::GetInfo for the details */
+    const aiImporterDesc *GetInfo() const override;
+
+    // -------------------------------------------------------------------
+    /** Imports the given file into the given scene structure.
+    * See BaseImporter::InternReadFile() for details */
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
+
+private:
+    struct TempJoint;
+    void CollectChildJoints(const std::vector<TempJoint> &joints, std::vector<bool> &hadit, aiNode *nd, const aiMatrix4x4 &absTrafo);
+    void CollectChildJoints(const std::vector<TempJoint> &joints, aiNode *nd);
+
+    template <typename T>
+    void ReadComments(StreamReaderLE &stream, std::vector<T> &outp);
+
+private:
+    aiScene *mScene;
+
+private:
+    struct TempVertex {
+        aiVector3D pos;
+        unsigned int bone_id[4], ref_cnt;
+        float weights[4];
+    };
+
+    struct TempTriangle {
+        unsigned int indices[3];
+        aiVector3D normals[3];
+        aiVector2D uv[3];
+
+        unsigned int sg, group;
+    };
+
+    struct TempGroup {
+        char name[33]; // +0
+        std::vector<unsigned int> triangles;
+        unsigned int mat; // 0xff is no material
+        std::string comment;
+    };
+
+    struct TempMaterial {
+        // again, add an extra 0 character to all strings -
+        char name[33];
+        char texture[129];
+        char alphamap[129];
+
+        aiColor4D diffuse, specular, ambient, emissive;
+        float shininess, transparency;
+        std::string comment;
+    };
+
+    struct TempKeyFrame {
+        float time;
+        aiVector3D value;
+    };
+
+    struct TempJoint {
+        char name[33];
+        char parentName[33];
+        aiVector3D rotation, position;
+
+        std::vector<TempKeyFrame> rotFrames;
+        std::vector<TempKeyFrame> posFrames;
+        std::string comment;
+    };
+
+    //struct TempModel {
+    //  std::string comment;
+    //};
+};
+
+} // namespace Assimp
+#endif