NvCloth 1.1.4 Release. (24070740)

1 files changed, 1161 insertions, 0 deletions

diff --git a/NvCloth/samples/external/assimp-4.1.0/code/SMDLoader.cpp b/NvCloth/samples/external/assimp-4.1.0/code/SMDLoader.cpp
new file mode 100644
index 0000000..60e3f63
--- /dev/null
+++ b/NvCloth/samples/external/assimp-4.1.0/code/SMDLoader.cpp
@@ -0,0 +1,1161 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2017, 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
+
+// internal headers
+#include "SMDLoader.h"
+#include "fast_atof.h"
+#include "SkeletonMeshBuilder.h"
+#include <assimp/Importer.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/importerdesc.h>
+#include <memory>
+
+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( -1 ),
+dLengthOfAnim( 0.0 ),
+bHasUVs(false ),
+iLineNumber(-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& pFile, IOSystem* /*pIOHandler*/, bool) const
+{
+    // fixme: auto format detection
+    return SimpleExtensionCheck(pFile,"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);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
+{
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+
+    // Check whether we can read from the file
+    if( file.get() == NULL) {
+        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
+    this->pScene = pScene;
+
+    mBuffer.resize( iFileSize + 1 );
+    TextFileToBuffer(file.get(), mBuffer );
+
+    iSmallestFrame = (1 << 31);
+    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);
+
+
+    // parse the file ...
+    ParseFile();
+
+    // 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())
+            {
+                DefaultLogger::get()->warn("SMD: Not all bones have been initialized");
+                break;
+            }
+        }
+
+        // now fix invalid time values and make sure the animation starts at frame 0
+        FixTimeValues();
+
+        // compute absolute bone transformation matrices
+    //  ComputeAbsoluteBoneTransformations();
+    }
+
+    if (!(pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE))
+    {
+        // create output meshes
+        CreateOutputMeshes();
+
+        // build an output material list
+        CreateOutputMaterials();
+    }
+
+    // build the output animation
+    CreateOutputAnimations();
+
+    // build output nodes (bones are added as empty dummy nodes)
+    CreateOutputNodes();
+
+    if (pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE)
+    {
+        SkeletonMeshBuilder skeleton(pScene);
+    }
+}
+// ------------------------------------------------------------------------------------------------
+// Write an error message with line number to the log file
+void SMDImporter::LogErrorNoThrow(const char* msg)
+{
+    char szTemp[1024];
+    ai_snprintf(szTemp,1024,"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)
+{
+    char szTemp[1024];
+    ai_assert(strlen(msg) < 1000);
+    ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,msg);
+    DefaultLogger::get()->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())
+        {
+            DefaultLogger::get()->error("[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 = NULL;
+        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)
+                    {
+                        DefaultLogger::get()->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())
+                    {
+                        DefaultLogger::get()->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 (false && 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( NULL != pcNode );
+    ai_assert( 0 == pcNode->mNumChildren );
+    ai_assert( NULL == 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
+        pc->mTransformation = bone.sAnim.asKeys[bone.sAnim.iFirstTimeKey].matrix;
+        pc->mParent = pcNode;
+
+        // add children to this node, too
+        AddBoneChildren(pc,i);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// create output nodes
+void SMDImporter::CreateOutputNodes()
+{
+    pScene->mRootNode = new aiNode();
+    if (!(pScene->mFlags & AI_SCENE_FLAGS_INCOMPLETE))
+    {
+        // create one 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;
+    }
+
+    // now add all bones as dummy sub nodes to the graph
+    // AddBoneChildren(pScene->mRootNode,(uint32_t)-1);
+
+    // 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] = NULL;
+        delete pcOldRoot;
+
+        pScene->mRootNode->mParent = NULL;
+    }
+    else
+    {
+        ::strcpy(pScene->mRootNode->mName.data, "<SMD_root>");
+        pScene->mRootNode->mName.length = 10;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// create output animations
+void SMDImporter::CreateOutputAnimations()
+{
+    unsigned int iNumBones = 0;
+    for (std::vector<SMD::Bone>::const_iterator
+        i =  asBones.begin();
+        i != asBones.end();++i)
+    {
+        if ((*i).bIsUsed)++iNumBones;
+    }
+    if (!iNumBones)
+    {
+        // just make sure this case doesn't occur ... (it could occur
+        // if the file was invalid)
+        return;
+    }
+
+    pScene->mNumAnimations = 1;
+    pScene->mAnimations = new aiAnimation*[1];
+    aiAnimation*& anim = pScene->mAnimations[0] = new aiAnimation();
+
+    anim->mDuration = dLengthOfAnim;
+    anim->mNumChannels = iNumBones;
+    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)
+    {
+        if (!(*i).bIsUsed)continue;
+
+        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
+                pRotKeys->mValue = aiQuaternion( (*qq).vRot.x, (*qq).vRot.y, (*qq).vRot.z );
+                pVecKeys->mValue = (*qq).vPos;
+
+                ++pVecKeys; ++pRotKeys;
+            }
+        }
+        ++a;
+
+        // there are no scaling keys ...
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SMDImporter::ComputeAbsoluteBoneTransformations()
+{
+    // For each bone: determine the key with the lowest time value
+    // theoretically the SMD format should have all keyframes
+    // in order. However, I've seen a file where this wasn't true.
+    for (unsigned int i = 0; i < asBones.size();++i)
+    {
+        SMD::Bone& bone = asBones[i];
+
+        uint32_t iIndex = 0;
+        double dMin = 10e10;
+        for (unsigned int i = 0; i < bone.sAnim.asKeys.size();++i)
+        {
+            double d = std::min(bone.sAnim.asKeys[i].dTime,dMin);
+            if (d < dMin)
+            {
+                dMin = d;
+                iIndex = i;
+            }
+        }
+        bone.sAnim.iFirstTimeKey = iIndex;
+    }
+
+    unsigned int iParent = 0;
+    while (iParent < asBones.size())
+    {
+        for (unsigned int iBone = 0; iBone < asBones.size();++iBone)
+        {
+            SMD::Bone& bone = asBones[iBone];
+
+            if (iParent == bone.iParent)
+            {
+                SMD::Bone& parentBone = asBones[iParent];
+
+
+                uint32_t iIndex = bone.sAnim.iFirstTimeKey;
+                const aiMatrix4x4& mat = bone.sAnim.asKeys[iIndex].matrix;
+                aiMatrix4x4& matOut = bone.sAnim.asKeys[iIndex].matrixAbsolute;
+
+                // The same for the parent bone ...
+                iIndex = parentBone.sAnim.iFirstTimeKey;
+                const aiMatrix4x4& mat2 = parentBone.sAnim.asKeys[iIndex].matrixAbsolute;
+
+                // Compute the absolute transformation matrix
+                matOut = mat * mat2;
+            }
+        }
+        ++iParent;
+    }
+
+    // Store the inverse of the absolute transformation matrix
+    // of the first key as bone offset matrix
+    for (iParent = 0; iParent < asBones.size();++iParent)
+    {
+        SMD::Bone& bone = asBones[iParent];
+        bone.mOffsetMatrix = bone.sAnim.asKeys[bone.sAnim.iFirstTimeKey].matrixAbsolute;
+        bone.mOffsetMatrix.Inverse();
+    }
+}
+\
+// ------------------------------------------------------------------------------------------------
+// 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 = 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 = (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))
+            {
+                DefaultLogger::get()->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);
+    }
+    return;
+}
+
+// ------------------------------------------------------------------------------------------------
+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;
+
+        // "time <n>\n" - Specifies the current animation frame
+        else if (TokenMatch(szCurrent,"time",4))
+        {
+            // NOTE: The doc says that time values COULD be negative ...
+            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 expcted 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 (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))
+    {
+        DefaultLogger::get()->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 = key.matrix * mTemp;
+    }
+
+    // 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