add assimp submodule

1 files changed, 1098 insertions, 0 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/SMD/SMDLoader.cpp b/src/mesh/assimp-master/code/AssetLib/SMD/SMDLoader.cpp
new file mode 100644
index 0000000..46fd968
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/SMD/SMDLoader.cpp
@@ -0,0 +1,1098 @@
+/*
+---------------------------------------------------------------------------
+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  SMDLoader.cpp
+ *  @brief Implementation of the SMD importer class
+ */
+
+
+#ifndef ASSIMP_BUILD_NO_SMD_IMPORTER
+
+#include <assimp/fast_atof.h>
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/Importer.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/importerdesc.h>
+#include <memory>
+#include <assimp/DefaultIOSystem.h>
+#include <tuple>
+
+// internal headers
+#include "SMDLoader.h"
+
+#ifndef _MSC_VER
+#define strtok_s strtok_r
+#endif
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+    "Valve SMD Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "smd vta"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+SMDImporter::SMDImporter() :
+        configFrameID(), 
+        mBuffer(), 
+        pScene( nullptr ), 
+        iFileSize( 0 ), 
+        iSmallestFrame( INT_MAX ),
+        dLengthOfAnim( 0.0 ),
+        bHasUVs(false ), 
+        iLineNumber((unsigned int)-1)  {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+SMDImporter::~SMDImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool SMDImporter::CanRead( const std::string& filename, IOSystem* /*pIOHandler*/, bool) const {
+    return SimpleExtensionCheck(filename, "smd", "vta");
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get a list of all supported file extensions
+const aiImporterDesc* SMDImporter::GetInfo () const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup configuration properties
+void SMDImporter::SetupProperties(const Importer* pImp) {
+    // The
+    // AI_CONFIG_IMPORT_SMD_KEYFRAME option overrides the
+    // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
+    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_SMD_KEYFRAME,-1);
+    if(static_cast<unsigned int>(-1) == configFrameID)  {
+        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+    }
+
+    bLoadAnimationList = pImp->GetPropertyBool(AI_CONFIG_IMPORT_SMD_LOAD_ANIMATION_LIST, true);
+    noSkeletonMesh = pImp->GetPropertyBool(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, false);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void SMDImporter::InternReadFile( const std::string& pFile, aiScene* scene, IOSystem* pIOHandler) {
+    this->pScene = scene;
+    ReadSmd(pFile, pIOHandler);
+
+    // If there are no triangles it seems to be an animation SMD,
+    // containing only the animation skeleton.
+    if (asTriangles.empty()) {
+        if (asBones.empty()) {
+            throw DeadlyImportError("SMD: No triangles and no bones have "
+                "been found in the file. This file seems to be invalid.");
+        }
+
+        // Set the flag in the scene structure which indicates
+        // that there is nothing than an animation skeleton
+        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    }
+
+    if (!asBones.empty()) {
+        // Check whether all bones have been initialized
+        for (std::vector<SMD::Bone>::const_iterator
+                i =  asBones.begin();
+                i != asBones.end();++i) {
+            if (!(*i).mName.length()) {
+                ASSIMP_LOG_WARN("SMD: Not all bones have been initialized");
+                break;
+            }
+        }
+
+        // now fix invalid time values and make sure the animation starts at frame 0
+        FixTimeValues();
+    }
+
+    // build output nodes (bones are added as empty dummy nodes)
+    CreateOutputNodes();
+
+    if (!(pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)) {
+        // create output meshes
+        CreateOutputMeshes();
+
+        // build an output material list
+        CreateOutputMaterials();
+
+        // use root node that renders all meshes
+        pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
+        pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
+        for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+            pScene->mRootNode->mMeshes[i] = i;
+        }
+    }
+
+    // build the output animation
+    CreateOutputAnimations(pFile, pIOHandler);
+
+    if ((pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE) && !noSkeletonMesh) {
+        SkeletonMeshBuilder skeleton(pScene);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write an error message with line number to the log file
+void SMDImporter::LogErrorNoThrow(const char* msg) {
+    const size_t _BufferSize = 1024;
+    char szTemp[_BufferSize];
+    ai_snprintf(szTemp,_BufferSize,"Line %u: %s",iLineNumber,msg);
+    DefaultLogger::get()->error(szTemp);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write a warning with line number to the log file
+void SMDImporter::LogWarning(const char* msg) {
+    const size_t _BufferSize = 1024;
+    char szTemp[_BufferSize];
+    ai_assert(strlen(msg) < 1000);
+    ai_snprintf(szTemp,_BufferSize,"Line %u: %s",iLineNumber,msg);
+    ASSIMP_LOG_WARN(szTemp);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Fix invalid time values in the file
+void SMDImporter::FixTimeValues() {
+    double dDelta = (double)iSmallestFrame;
+    double dMax = 0.0f;
+    for (std::vector<SMD::Bone>::iterator
+            iBone =  asBones.begin();
+            iBone != asBones.end();++iBone) {
+        for (std::vector<SMD::Bone::Animation::MatrixKey>::iterator
+                iKey =  (*iBone).sAnim.asKeys.begin();
+                iKey != (*iBone).sAnim.asKeys.end();++iKey) {
+            (*iKey).dTime -= dDelta;
+            dMax = std::max(dMax, (*iKey).dTime);
+        }
+    }
+    dLengthOfAnim = dMax;
+}
+
+// ------------------------------------------------------------------------------------------------
+// create output meshes
+void SMDImporter::CreateOutputMeshes() {
+    if (aszTextures.empty()) {
+        aszTextures.push_back(std::string());
+    }
+
+    // we need to sort all faces by their material index
+    // in opposition to other loaders we can be sure that each
+    // material is at least used once.
+    pScene->mNumMeshes = (unsigned int) aszTextures.size();
+    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+
+    typedef std::vector<unsigned int> FaceList;
+    FaceList* aaiFaces = new FaceList[pScene->mNumMeshes];
+
+    // approximate the space that will be required
+    unsigned int iNum = (unsigned int)asTriangles.size() / pScene->mNumMeshes;
+    iNum += iNum >> 1;
+    for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
+        aaiFaces[i].reserve(iNum);
+    }
+
+    // collect all faces
+    iNum = 0;
+    for (std::vector<SMD::Face>::const_iterator
+            iFace =  asTriangles.begin();
+            iFace != asTriangles.end();++iFace,++iNum) {
+        if (UINT_MAX == (*iFace).iTexture) {
+            aaiFaces[(*iFace).iTexture].push_back( 0 );
+        } else if ((*iFace).iTexture >= aszTextures.size()) {
+            ASSIMP_LOG_INFO("[SMD/VTA] Material index overflow in face");
+            aaiFaces[(*iFace).iTexture].push_back((unsigned int)aszTextures.size()-1);
+        } else {
+            aaiFaces[(*iFace).iTexture].push_back(iNum);
+        }
+    }
+
+    // now create the output meshes
+    for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
+        aiMesh*& pcMesh = pScene->mMeshes[i] = new aiMesh();
+        ai_assert(!aaiFaces[i].empty()); // should not be empty ...
+
+        pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+        pcMesh->mNumVertices = (unsigned int)aaiFaces[i].size()*3;
+        pcMesh->mNumFaces = (unsigned int)aaiFaces[i].size();
+        pcMesh->mMaterialIndex = i;
+
+        // storage for bones
+        typedef std::pair<unsigned int,float> TempWeightListEntry;
+        typedef std::vector< TempWeightListEntry > TempBoneWeightList;
+
+        TempBoneWeightList* aaiBones = new TempBoneWeightList[asBones.size()]();
+
+        // try to reserve enough memory without wasting too much
+        for (unsigned int iBone = 0; iBone < asBones.size();++iBone) {
+            aaiBones[iBone].reserve(pcMesh->mNumVertices/asBones.size());
+        }
+
+        // allocate storage
+        pcMesh->mFaces = new aiFace[pcMesh->mNumFaces];
+        aiVector3D* pcNormals = pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
+        aiVector3D* pcVerts = pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
+
+        aiVector3D* pcUVs = nullptr;
+        if (bHasUVs) {
+            pcUVs = pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
+            pcMesh->mNumUVComponents[0] = 2;
+        }
+
+        iNum = 0;
+        for (unsigned int iFace = 0; iFace < pcMesh->mNumFaces;++iFace) {
+            pcMesh->mFaces[iFace].mIndices = new unsigned int[3];
+            pcMesh->mFaces[iFace].mNumIndices = 3;
+
+            // fill the vertices
+            unsigned int iSrcFace = aaiFaces[i][iFace];
+            SMD::Face& face = asTriangles[iSrcFace];
+
+            *pcVerts++ = face.avVertices[0].pos;
+            *pcVerts++ = face.avVertices[1].pos;
+            *pcVerts++ = face.avVertices[2].pos;
+
+            // fill the normals
+            *pcNormals++ = face.avVertices[0].nor;
+            *pcNormals++ = face.avVertices[1].nor;
+            *pcNormals++ = face.avVertices[2].nor;
+
+            // fill the texture coordinates
+            if (pcUVs) {
+                *pcUVs++ = face.avVertices[0].uv;
+                *pcUVs++ = face.avVertices[1].uv;
+                *pcUVs++ = face.avVertices[2].uv;
+            }
+
+            for (unsigned int iVert = 0; iVert < 3;++iVert) {
+                float fSum = 0.0f;
+                for (unsigned int iBone = 0;iBone < face.avVertices[iVert].aiBoneLinks.size();++iBone)  {
+                    TempWeightListEntry& pairval = face.avVertices[iVert].aiBoneLinks[iBone];
+
+                    // FIX: The second check is here just to make sure we won't
+                    // assign more than one weight to a single vertex index
+                    if (pairval.first >= asBones.size() || pairval.first == face.avVertices[iVert].iParentNode) {
+                        ASSIMP_LOG_ERROR("[SMD/VTA] Bone index overflow. "
+                            "The bone index will be ignored, the weight will be assigned "
+                            "to the vertex' parent node");
+                        continue;
+                    }
+                    aaiBones[pairval.first].push_back(TempWeightListEntry(iNum,pairval.second));
+                    fSum += pairval.second;
+                }
+                // ******************************************************************
+                // If the sum of all vertex weights is not 1.0 we must assign
+                // the rest to the vertex' parent node. Well, at least the doc says
+                // we should ...
+                // FIX: We use 0.975 as limit, floating-point inaccuracies seem to
+                // be very strong in some SMD exporters. Furthermore it is possible
+                // that the parent of a vertex is 0xffffffff (if the corresponding
+                // entry in the file was unreadable)
+                // ******************************************************************
+                if (fSum < 0.975f && face.avVertices[iVert].iParentNode != UINT_MAX) {
+                    if (face.avVertices[iVert].iParentNode >= asBones.size()) {
+                        ASSIMP_LOG_ERROR("[SMD/VTA] Bone index overflow. "
+                            "The index of the vertex parent bone is invalid. "
+                            "The remaining weights will be normalized to 1.0");
+
+                        if (fSum) {
+                            fSum = 1 / fSum;
+                            for (unsigned int iBone = 0;iBone < face.avVertices[iVert].aiBoneLinks.size();++iBone) {
+                                TempWeightListEntry& pairval = face.avVertices[iVert].aiBoneLinks[iBone];
+                                if (pairval.first >= asBones.size()) {
+                                    continue;
+                                }
+                                aaiBones[pairval.first].back().second *= fSum;
+                            }
+                        }
+                    } else {
+                        aaiBones[face.avVertices[iVert].iParentNode].push_back(
+                            TempWeightListEntry(iNum,1.0f-fSum));
+                    }
+                }
+                pcMesh->mFaces[iFace].mIndices[iVert] = iNum++;
+            }
+        }
+
+        // now build all bones of the mesh
+        iNum = 0;
+        for (unsigned int iBone = 0; iBone < asBones.size();++iBone) {
+            if (!aaiBones[iBone].empty())++iNum;
+        }
+
+        if (iNum) {
+            pcMesh->mNumBones = iNum;
+            pcMesh->mBones = new aiBone*[pcMesh->mNumBones];
+            iNum = 0;
+            for (unsigned int iBone = 0; iBone < asBones.size();++iBone) {
+                if (aaiBones[iBone].empty()) {
+                    continue;
+                }
+                aiBone*& bone = pcMesh->mBones[iNum] = new aiBone();
+
+                bone->mNumWeights = (unsigned int)aaiBones[iBone].size();
+                bone->mWeights = new aiVertexWeight[bone->mNumWeights];
+                bone->mOffsetMatrix = asBones[iBone].mOffsetMatrix;
+                bone->mName.Set( asBones[iBone].mName );
+
+                asBones[iBone].bIsUsed = true;
+
+                for (unsigned int iWeight = 0; iWeight < bone->mNumWeights;++iWeight) {
+                    bone->mWeights[iWeight].mVertexId = aaiBones[iBone][iWeight].first;
+                    bone->mWeights[iWeight].mWeight = aaiBones[iBone][iWeight].second;
+                }
+                ++iNum;
+            }
+        }
+        delete[] aaiBones;
+    }
+    delete[] aaiFaces;
+}
+
+// ------------------------------------------------------------------------------------------------
+// add bone child nodes
+void SMDImporter::AddBoneChildren(aiNode* pcNode, uint32_t iParent) {
+    ai_assert( nullptr != pcNode );
+    ai_assert( 0 == pcNode->mNumChildren );
+    ai_assert( nullptr == pcNode->mChildren);
+
+    // first count ...
+    for (unsigned int i = 0; i < asBones.size();++i) {
+        SMD::Bone& bone = asBones[i];
+        if (bone.iParent == iParent) {
+            ++pcNode->mNumChildren;
+        }
+    }
+
+    // now allocate the output array
+    pcNode->mChildren = new aiNode*[pcNode->mNumChildren];
+
+    // and fill all subnodes
+    unsigned int qq( 0 );
+    for (unsigned int i = 0; i < asBones.size();++i) {
+        SMD::Bone& bone = asBones[i];
+        if (bone.iParent != iParent) {
+            continue;
+        }
+
+        aiNode* pc = pcNode->mChildren[qq++] = new aiNode();
+        pc->mName.Set(bone.mName);
+
+        // store the local transformation matrix of the bind pose
+        if (bone.sAnim.asKeys.size()) {
+            pc->mTransformation = bone.sAnim.asKeys[0].matrix;
+        }
+
+        if (bone.iParent == static_cast<uint32_t>(-1)) {
+            bone.mOffsetMatrix = pc->mTransformation;
+        } else {
+            bone.mOffsetMatrix = asBones[bone.iParent].mOffsetMatrix * pc->mTransformation;
+        }
+
+        pc->mParent = pcNode;
+
+        // add children to this node, too
+        AddBoneChildren(pc,i);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// create output nodes
+void SMDImporter::CreateOutputNodes() {
+    pScene->mRootNode = new aiNode();
+
+    // now add all bones as dummy sub nodes to the graph
+    AddBoneChildren(pScene->mRootNode,(uint32_t)-1);
+    for (auto &bone : asBones) {
+        bone.mOffsetMatrix.Inverse();
+    }
+
+    // if we have only one bone we can even remove the root node
+    if (pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE && 1 == pScene->mRootNode->mNumChildren) {
+        aiNode* pcOldRoot = pScene->mRootNode;
+        pScene->mRootNode = pcOldRoot->mChildren[0];
+        pcOldRoot->mChildren[0] = nullptr;
+        delete pcOldRoot;
+
+        pScene->mRootNode->mParent = nullptr;
+    }
+    else
+    {
+        ::strcpy(pScene->mRootNode->mName.data, "<SMD_root>");
+        pScene->mRootNode->mName.length = 10;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// create output animations
+void SMDImporter::CreateOutputAnimations(const std::string &pFile, IOSystem* pIOHandler) {
+    std::vector<std::tuple<std::string, std::string>> animFileList;
+
+    if (bLoadAnimationList) {
+        GetAnimationFileList(pFile, pIOHandler, animFileList);
+    }
+    int animCount = static_cast<int>( animFileList.size() + 1u );
+    pScene->mNumAnimations = 1;
+    pScene->mAnimations = new aiAnimation*[animCount];
+    memset(pScene->mAnimations, 0, sizeof(aiAnimation*)*animCount);
+    CreateOutputAnimation(0, "");
+
+    for (auto &animFile : animFileList) {
+        ReadSmd(std::get<1>(animFile), pIOHandler);
+        if (asBones.empty()) {
+            continue;
+        }
+
+        FixTimeValues();
+        CreateOutputAnimation(pScene->mNumAnimations++, std::get<0>(animFile));
+    }
+}
+
+void SMDImporter::CreateOutputAnimation(int index, const std::string &name) {
+    aiAnimation*& anim = pScene->mAnimations[index] = new aiAnimation();
+
+    if (name.length()) {
+        anim->mName.Set(name.c_str());
+    }
+    anim->mDuration = dLengthOfAnim;
+    anim->mNumChannels = static_cast<unsigned int>( asBones.size() );
+    anim->mTicksPerSecond = 25.0; // FIXME: is this correct?
+
+    aiNodeAnim** pp = anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
+
+    // now build valid keys
+    unsigned int a = 0;
+    for (std::vector<SMD::Bone>::const_iterator i = asBones.begin(); i != asBones.end(); ++i) {
+        aiNodeAnim* p = pp[a] = new aiNodeAnim();
+
+        // copy the name of the bone
+        p->mNodeName.Set(i->mName);
+
+        p->mNumRotationKeys = (unsigned int)(*i).sAnim.asKeys.size();
+        if (p->mNumRotationKeys){
+            p->mNumPositionKeys = p->mNumRotationKeys;
+            aiVectorKey* pVecKeys = p->mPositionKeys = new aiVectorKey[p->mNumRotationKeys];
+            aiQuatKey* pRotKeys = p->mRotationKeys = new aiQuatKey[p->mNumRotationKeys];
+
+            for (std::vector<SMD::Bone::Animation::MatrixKey>::const_iterator
+                    qq = (*i).sAnim.asKeys.begin();
+                    qq != (*i).sAnim.asKeys.end(); ++qq) {
+                pRotKeys->mTime = pVecKeys->mTime = (*qq).dTime;
+
+                // compute the rotation quaternion from the euler angles
+                // aiQuaternion: The order of the parameters is yzx?
+                pRotKeys->mValue = aiQuaternion((*qq).vRot.y, (*qq).vRot.z, (*qq).vRot.x);
+                pVecKeys->mValue = (*qq).vPos;
+
+                ++pVecKeys; ++pRotKeys;
+            }
+        }
+        ++a;
+
+        // there are no scaling keys ...
+    }
+}
+
+void SMDImporter::GetAnimationFileList(const std::string &pFile, IOSystem* pIOHandler, std::vector<std::tuple<std::string, std::string>>& outList) {
+    auto base = DefaultIOSystem::absolutePath(pFile);
+    auto name = DefaultIOSystem::completeBaseName(pFile);
+    auto path = base + "/" + name + "_animation.txt";
+
+    std::unique_ptr<IOStream> file(pIOHandler->Open(path.c_str(), "rb"));
+    if (file.get() == nullptr) {
+        return;
+    }
+
+    // Allocate storage and copy the contents of the file to a memory buffer
+    std::vector<char> buf;
+    size_t fileSize = file->FileSize();
+    buf.resize(fileSize + 1);
+    TextFileToBuffer(file.get(), buf);
+
+    /*
+        *_animation.txt format:
+        name path
+        idle idle.smd
+        jump anim/jump.smd
+        walk.smd
+        ...
+    */
+    std::string animName, animPath;
+    char *tok1, *tok2;
+    char *context1, *context2;
+
+    tok1 = strtok_s(&buf[0], "\r\n", &context1);
+    while (tok1 != nullptr) {
+        tok2 = strtok_s(tok1, " \t", &context2);
+        if (tok2) {
+            char *p = tok2;
+            tok2 = strtok_s(nullptr, " \t", &context2);
+            if (tok2) {
+                animPath = tok2;
+                animName = p;
+            } else  {
+                // No name
+                animPath = p;
+                animName = DefaultIOSystem::completeBaseName(animPath);
+            }
+            outList.push_back(std::make_tuple(animName, base + "/" + animPath));
+        }
+        tok1 = strtok_s(nullptr, "\r\n", &context1);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// create output materials
+void SMDImporter::CreateOutputMaterials() {
+    ai_assert( nullptr != pScene );
+
+    pScene->mNumMaterials = (unsigned int)aszTextures.size();
+    pScene->mMaterials = new aiMaterial*[std::max(1u, pScene->mNumMaterials)];
+
+    for (unsigned int iMat = 0; iMat < pScene->mNumMaterials; ++iMat) {
+        aiMaterial* pcMat = new aiMaterial();
+        ai_assert( nullptr != pcMat );
+        pScene->mMaterials[iMat] = pcMat;
+
+        aiString szName;
+        szName.length = (size_t)ai_snprintf(szName.data,MAXLEN,"Texture_%u",iMat);
+        pcMat->AddProperty(&szName,AI_MATKEY_NAME);
+
+        if (aszTextures[iMat].length())
+        {
+            ::strncpy(szName.data, aszTextures[iMat].c_str(),MAXLEN-1);
+            szName.length = static_cast<ai_uint32>( aszTextures[iMat].length() );
+            pcMat->AddProperty(&szName,AI_MATKEY_TEXTURE_DIFFUSE(0));
+        }
+    }
+
+    // create a default material if necessary
+    if (0 == pScene->mNumMaterials) {
+        pScene->mNumMaterials = 1;
+
+        aiMaterial* pcHelper = new aiMaterial();
+        pScene->mMaterials[0] = pcHelper;
+
+        int iMode = static_cast<int>(aiShadingMode_Gouraud);
+        pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
+
+        aiColor3D clr;
+        clr.b = clr.g = clr.r = 0.7f;
+        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_DIFFUSE);
+        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_SPECULAR);
+
+        clr.b = clr.g = clr.r = 0.05f;
+        pcHelper->AddProperty<aiColor3D>(&clr, 1,AI_MATKEY_COLOR_AMBIENT);
+
+        aiString szName;
+        szName.Set(AI_DEFAULT_MATERIAL_NAME);
+        pcHelper->AddProperty(&szName,AI_MATKEY_NAME);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse the file
+void SMDImporter::ParseFile() {
+    const char* szCurrent = &mBuffer[0];
+
+    // read line per line ...
+    for ( ;; ) {
+        if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) {
+            break;
+        }
+
+        // "version <n> \n", <n> should be 1 for hl and hl2 SMD files
+        if (TokenMatch(szCurrent,"version",7)) {
+            if(!SkipSpaces(szCurrent,&szCurrent)) break;
+            if (1 != strtoul10(szCurrent,&szCurrent)) {
+                ASSIMP_LOG_WARN("SMD.version is not 1. This "
+                    "file format is not known. Continuing happily ...");
+            }
+            continue;
+        }
+        // "nodes\n" - Starts the node section
+        if (TokenMatch(szCurrent,"nodes",5)) {
+            ParseNodesSection(szCurrent,&szCurrent);
+            continue;
+        }
+        // "triangles\n" - Starts the triangle section
+        if (TokenMatch(szCurrent,"triangles",9)) {
+            ParseTrianglesSection(szCurrent,&szCurrent);
+            continue;
+        }
+        // "vertexanimation\n" - Starts the vertex animation section
+        if (TokenMatch(szCurrent,"vertexanimation",15)) {
+            bHasUVs = false;
+            ParseVASection(szCurrent,&szCurrent);
+            continue;
+        }
+        // "skeleton\n" - Starts the skeleton section
+        if (TokenMatch(szCurrent,"skeleton",8)) {
+            ParseSkeletonSection(szCurrent,&szCurrent);
+            continue;
+        }
+        SkipLine(szCurrent,&szCurrent);
+    }
+}
+
+void SMDImporter::ReadSmd(const std::string &pFile, IOSystem* pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
+
+    // Check whether we can read from the file
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open SMD/VTA file ", pFile, ".");
+    }
+
+    iFileSize = (unsigned int)file->FileSize();
+
+    // Allocate storage and copy the contents of the file to a memory buffer
+    mBuffer.resize(iFileSize + 1);
+    TextFileToBuffer(file.get(), mBuffer);
+
+    iSmallestFrame = INT_MAX;
+    bHasUVs = true;
+    iLineNumber = 1;
+
+    // Reserve enough space for ... hm ... 10 textures
+    aszTextures.reserve(10);
+
+    // Reserve enough space for ... hm ... 1000 triangles
+    asTriangles.reserve(1000);
+
+    // Reserve enough space for ... hm ... 20 bones
+    asBones.reserve(20);
+
+    aszTextures.clear();
+    asTriangles.clear();
+    asBones.clear();
+
+    // parse the file ...
+    ParseFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned int SMDImporter::GetTextureIndex(const std::string& filename) {
+    unsigned int iIndex = 0;
+    for (std::vector<std::string>::const_iterator
+            i =  aszTextures.begin();
+            i != aszTextures.end();++i,++iIndex) {
+        // case-insensitive ... it's a path
+        if (0 == ASSIMP_stricmp ( filename.c_str(),(*i).c_str())) {
+            return iIndex;
+        }
+    }
+    iIndex = (unsigned int)aszTextures.size();
+    aszTextures.push_back(filename);
+    return iIndex;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse the nodes section of the file
+void SMDImporter::ParseNodesSection(const char* szCurrent, const char** szCurrentOut) {
+    for ( ;; ) {
+        // "end\n" - Ends the nodes section
+        if (0 == ASSIMP_strincmp(szCurrent,"end",3) && IsSpaceOrNewLine(*(szCurrent+3))) {
+            szCurrent += 4;
+            break;
+        }
+        ParseNodeInfo(szCurrent,&szCurrent);
+    }
+    SkipSpacesAndLineEnd(szCurrent,&szCurrent);
+    *szCurrentOut = szCurrent;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse the triangles section of the file
+void SMDImporter::ParseTrianglesSection(const char* szCurrent, const char** szCurrentOut) {
+    // Parse a triangle, parse another triangle, parse the next triangle ...
+    // and so on until we reach a token that looks quite similar to "end"
+    for ( ;; ) {
+        if(!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) {
+            break;
+        }
+
+        // "end\n" - Ends the triangles section
+        if (TokenMatch(szCurrent,"end",3)) {
+            break;
+        }
+        ParseTriangle(szCurrent,&szCurrent);
+    }
+    SkipSpacesAndLineEnd(szCurrent,&szCurrent);
+    *szCurrentOut = szCurrent;
+}
+// ------------------------------------------------------------------------------------------------
+// Parse the vertex animation section of the file
+void SMDImporter::ParseVASection(const char* szCurrent, const char** szCurrentOut) {
+    unsigned int iCurIndex = 0;
+    for ( ;; ) {
+        if (!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) {
+            break;
+        }
+
+        // "end\n" - Ends the "vertexanimation" section
+        if (TokenMatch(szCurrent,"end",3)) {
+            break;
+        }
+
+        // "time <n>\n"
+        if (TokenMatch(szCurrent,"time",4)) {
+            // NOTE: The doc says that time values COULD be negative ...
+            // NOTE2: this is the shape key -> valve docs
+            int iTime = 0;
+            if(!ParseSignedInt(szCurrent,&szCurrent,iTime) || configFrameID != (unsigned int)iTime) {
+                break;
+            }
+            SkipLine(szCurrent,&szCurrent);
+        } else {
+            if(0 == iCurIndex) {
+                asTriangles.push_back(SMD::Face());
+            }
+            if (++iCurIndex == 3) {
+                iCurIndex = 0;
+            }
+            ParseVertex(szCurrent,&szCurrent,asTriangles.back().avVertices[iCurIndex],true);
+        }
+    }
+
+    if (iCurIndex != 2 && !asTriangles.empty()) {
+        // we want to no degenerates, so throw this triangle away
+        asTriangles.pop_back();
+    }
+
+    SkipSpacesAndLineEnd(szCurrent,&szCurrent);
+    *szCurrentOut = szCurrent;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse the skeleton section of the file
+void SMDImporter::ParseSkeletonSection(const char* szCurrent, const char** szCurrentOut) {
+    int iTime = 0;
+    for ( ;; ) {
+        if (!SkipSpacesAndLineEnd(szCurrent,&szCurrent)) {
+            break;
+        }
+
+        // "end\n" - Ends the skeleton section
+        if (TokenMatch(szCurrent,"end",3)) {
+            break;
+        } else if (TokenMatch(szCurrent,"time",4)) {
+        // "time <n>\n" - Specifies the current animation frame
+            if(!ParseSignedInt(szCurrent,&szCurrent,iTime)) {
+                break;
+            }
+
+            iSmallestFrame = std::min(iSmallestFrame,iTime);
+            SkipLine(szCurrent,&szCurrent);
+        } else {
+            ParseSkeletonElement(szCurrent,&szCurrent,iTime);
+        }
+    }
+    *szCurrentOut = szCurrent;
+}
+
+// ------------------------------------------------------------------------------------------------
+#define SMDI_PARSE_RETURN { \
+    SkipLine(szCurrent,&szCurrent); \
+    *szCurrentOut = szCurrent; \
+    return; \
+}
+// ------------------------------------------------------------------------------------------------
+// Parse a node line
+void SMDImporter::ParseNodeInfo(const char* szCurrent, const char** szCurrentOut) {
+    unsigned int iBone  = 0;
+    SkipSpacesAndLineEnd(szCurrent,&szCurrent);
+    if ( !ParseUnsignedInt(szCurrent,&szCurrent,iBone) || !SkipSpaces(szCurrent,&szCurrent)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone index");
+        SMDI_PARSE_RETURN;
+    }
+    // add our bone to the list
+    if (iBone >= asBones.size()) {
+        asBones.resize(iBone+1);
+    }
+    SMD::Bone& bone = asBones[iBone];
+
+    bool bQuota = true;
+    if ('\"' != *szCurrent) {
+        LogWarning("Bone name is expected to be enclosed in "
+            "double quotation marks. ");
+        bQuota = false;
+    } else {
+        ++szCurrent;
+    }
+
+    const char* szEnd = szCurrent;
+    for ( ;; ) {
+        if (bQuota && '\"' == *szEnd) {
+            iBone = (unsigned int)(szEnd - szCurrent);
+            ++szEnd;
+            break;
+        } else if (!bQuota && IsSpaceOrNewLine(*szEnd)) {
+            iBone = (unsigned int)(szEnd - szCurrent);
+            break;
+        } else if (!(*szEnd)) {
+            LogErrorNoThrow("Unexpected EOF/EOL while parsing bone name");
+            SMDI_PARSE_RETURN;
+        }
+        ++szEnd;
+    }
+    bone.mName = std::string(szCurrent,iBone);
+    szCurrent = szEnd;
+
+    // the only negative bone parent index that could occur is -1 AFAIK
+    if(!ParseSignedInt(szCurrent,&szCurrent,(int&)bone.iParent))  {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone parent index. Assuming -1");
+        SMDI_PARSE_RETURN;
+    }
+
+    // go to the beginning of the next line
+    SMDI_PARSE_RETURN;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a skeleton element
+void SMDImporter::ParseSkeletonElement(const char* szCurrent, const char** szCurrentOut,int iTime) {
+    aiVector3D vPos;
+    aiVector3D vRot;
+
+    unsigned int iBone  = 0;
+    if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone)) {
+        ASSIMP_LOG_ERROR("Unexpected EOF/EOL while parsing bone index");
+        SMDI_PARSE_RETURN;
+    }
+    if (iBone >= asBones.size()) {
+        LogErrorNoThrow("Bone index in skeleton section is out of range");
+        SMDI_PARSE_RETURN;
+    }
+    SMD::Bone& bone = asBones[iBone];
+
+    bone.sAnim.asKeys.push_back(SMD::Bone::Animation::MatrixKey());
+    SMD::Bone::Animation::MatrixKey& key = bone.sAnim.asKeys.back();
+
+    key.dTime = (double)iTime;
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.x)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.x");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.y)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.y");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vPos.z)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.pos.z");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.x)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.x");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.y)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.y");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vRot.z)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing bone.rot.z");
+        SMDI_PARSE_RETURN;
+    }
+    // build the transformation matrix of the key
+    key.matrix.FromEulerAnglesXYZ(vRot.x,vRot.y,vRot.z); {
+        aiMatrix4x4 mTemp;
+        mTemp.a4 = vPos.x;
+        mTemp.b4 = vPos.y;
+        mTemp.c4 = vPos.z;
+        key.matrix = mTemp * key.matrix;
+    }
+    key.vPos = vPos;
+    key.vRot = vRot;
+    // go to the beginning of the next line
+    SMDI_PARSE_RETURN;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a triangle
+void SMDImporter::ParseTriangle(const char* szCurrent, const char** szCurrentOut) {
+    asTriangles.push_back(SMD::Face());
+    SMD::Face& face = asTriangles.back();
+
+    if(!SkipSpaces(szCurrent,&szCurrent)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing a triangle");
+        return;
+    }
+
+    // read the texture file name
+    const char* szLast = szCurrent;
+    while (!IsSpaceOrNewLine(*++szCurrent));
+
+    // ... and get the index that belongs to this file name
+    face.iTexture = GetTextureIndex(std::string(szLast,(uintptr_t)szCurrent-(uintptr_t)szLast));
+
+    SkipSpacesAndLineEnd(szCurrent,&szCurrent);
+
+    // load three vertices
+    for (unsigned int iVert = 0; iVert < 3;++iVert) {
+        ParseVertex(szCurrent,&szCurrent, face.avVertices[iVert]);
+    }
+    *szCurrentOut = szCurrent;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a float
+bool SMDImporter::ParseFloat(const char* szCurrent, const char** szCurrentOut, float& out) {
+    if(!SkipSpaces(&szCurrent)) {
+        return false;
+    }
+
+    *szCurrentOut = fast_atoreal_move<float>(szCurrent,out);
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse an unsigned int
+bool SMDImporter::ParseUnsignedInt(const char* szCurrent, const char** szCurrentOut, unsigned int& out) {
+    if(!SkipSpaces(&szCurrent)) {
+        return false;
+    }
+
+    out = strtoul10(szCurrent,szCurrentOut);
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a signed int
+bool SMDImporter::ParseSignedInt(const char* szCurrent, const char** szCurrentOut, int& out) {
+    if(!SkipSpaces(&szCurrent)) {
+        return false;
+    }
+
+    out = strtol10(szCurrent,szCurrentOut);
+    return true;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a vertex
+void SMDImporter::ParseVertex(const char* szCurrent,
+        const char** szCurrentOut, SMD::Vertex& vertex,
+        bool bVASection /*= false*/) {
+    if (SkipSpaces(&szCurrent) && IsLineEnd(*szCurrent)) {
+        SkipSpacesAndLineEnd(szCurrent,&szCurrent);
+        return ParseVertex(szCurrent,szCurrentOut,vertex,bVASection);
+    }
+    if(!ParseSignedInt(szCurrent,&szCurrent,(int&)vertex.iParentNode)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.parent");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.pos.x)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.pos.x");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.pos.y)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.pos.y");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.pos.z)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.pos.z");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.nor.x)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.nor.x");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.nor.y)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.nor.y");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.nor.z)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.nor.z");
+        SMDI_PARSE_RETURN;
+    }
+
+    if (bVASection) {
+        SMDI_PARSE_RETURN;
+    }
+
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.uv.x)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.uv.x");
+        SMDI_PARSE_RETURN;
+    }
+    if(!ParseFloat(szCurrent,&szCurrent,(float&)vertex.uv.y)) {
+        LogErrorNoThrow("Unexpected EOF/EOL while parsing vertex.uv.y");
+        SMDI_PARSE_RETURN;
+    }
+
+    // now read the number of bones affecting this vertex
+    // all elements from now are fully optional, we don't need them
+    unsigned int iSize = 0;
+    if(!ParseUnsignedInt(szCurrent,&szCurrent,iSize)) {
+        SMDI_PARSE_RETURN;
+    }
+    vertex.aiBoneLinks.resize(iSize,std::pair<unsigned int, float>(0,0.0f));
+
+    for (std::vector<std::pair<unsigned int, float> >::iterator
+            i =  vertex.aiBoneLinks.begin();
+            i != vertex.aiBoneLinks.end();++i) {
+        if(!ParseUnsignedInt(szCurrent,&szCurrent,(*i).first)) {
+            SMDI_PARSE_RETURN;
+        }
+        if(!ParseFloat(szCurrent,&szCurrent,(*i).second)) {
+            SMDI_PARSE_RETURN;
+        }
+    }
+
+    // go to the beginning of the next line
+    SMDI_PARSE_RETURN;
+}
+
+#endif // !! ASSIMP_BUILD_NO_SMD_IMPORTER