add assimp submodule

1 files changed, 1360 insertions, 0 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/X/XFileParser.cpp b/src/mesh/assimp-master/code/AssetLib/X/XFileParser.cpp
new file mode 100644
index 0000000..558b979
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/X/XFileParser.cpp
@@ -0,0 +1,1360 @@
+/*
+---------------------------------------------------------------------------
+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 Implementation of the XFile parser helper class */
+
+#ifndef ASSIMP_BUILD_NO_X_IMPORTER
+
+#include "XFileParser.h"
+#include "XFileHelper.h"
+#include <assimp/ByteSwapper.h>
+#include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
+#include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
+#include <assimp/DefaultLogger.hpp>
+
+using namespace Assimp;
+using namespace Assimp::XFile;
+using namespace Assimp::Formatter;
+
+#ifndef ASSIMP_BUILD_NO_COMPRESSED_X
+
+#include "Common/Compression.h"
+
+// Magic identifier for MSZIP compressed data
+constexpr unsigned int MSZIP_MAGIC = 0x4B43;
+constexpr size_t MSZIP_BLOCK = 32786l;
+
+#endif // !! ASSIMP_BUILD_NO_COMPRESSED_X
+
+// ------------------------------------------------------------------------------------------------
+// Throws an exception with a line number and the given text.
+template<typename... T>
+AI_WONT_RETURN void XFileParser::ThrowException(T&&... args) {
+    if (mIsBinaryFormat) {
+        throw DeadlyImportError(args...);
+    } else {
+        throw DeadlyImportError("Line ", mLineNumber, ": ", args...);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor. Creates a data structure out of the XFile given in the memory block.
+XFileParser::XFileParser(const std::vector<char> &pBuffer) :
+        mMajorVersion(0), mMinorVersion(0), mIsBinaryFormat(false), mBinaryNumCount(0), mP(nullptr), mEnd(nullptr), mLineNumber(0), mScene(nullptr) {
+    // vector to store uncompressed file for INFLATE'd X files
+    std::vector<char> uncompressed;
+
+    // set up memory pointers
+    mP = &pBuffer.front();
+    mEnd = mP + pBuffer.size() - 1;
+
+    // check header
+    if (0 != strncmp(mP, "xof ", 4)) {
+        throw DeadlyImportError("Header mismatch, file is not an XFile.");
+    }
+
+    // read version. It comes in a four byte format such as "0302"
+    mMajorVersion = (unsigned int)(mP[4] - 48) * 10 + (unsigned int)(mP[5] - 48);
+    mMinorVersion = (unsigned int)(mP[6] - 48) * 10 + (unsigned int)(mP[7] - 48);
+
+    bool compressed = false;
+
+    // txt - pure ASCII text format
+    if (strncmp(mP + 8, "txt ", 4) == 0)
+        mIsBinaryFormat = false;
+
+    // bin - Binary format
+    else if (strncmp(mP + 8, "bin ", 4) == 0)
+        mIsBinaryFormat = true;
+
+    // tzip - Inflate compressed text format
+    else if (strncmp(mP + 8, "tzip", 4) == 0) {
+        mIsBinaryFormat = false;
+        compressed = true;
+    }
+    // bzip - Inflate compressed binary format
+    else if (strncmp(mP + 8, "bzip", 4) == 0) {
+        mIsBinaryFormat = true;
+        compressed = true;
+    } else
+        ThrowException("Unsupported x-file format '", mP[8], mP[9], mP[10], mP[11], "'");
+
+    // float size
+    mBinaryFloatSize = (unsigned int)(mP[12] - 48) * 1000 + (unsigned int)(mP[13] - 48) * 100 + (unsigned int)(mP[14] - 48) * 10 + (unsigned int)(mP[15] - 48);
+
+    if (mBinaryFloatSize != 32 && mBinaryFloatSize != 64)
+        ThrowException("Unknown float size ", mBinaryFloatSize, " specified in x-file header.");
+
+    // The x format specifies size in bits, but we work in bytes
+    mBinaryFloatSize /= 8;
+
+    mP += 16;
+
+    // If this is a compressed X file, apply the inflate algorithm to it
+    if (compressed) {
+#ifdef ASSIMP_BUILD_NO_COMPRESSED_X
+        throw DeadlyImportError("Assimp was built without compressed X support");
+#else
+        /* ///////////////////////////////////////////////////////////////////////
+         * COMPRESSED X FILE FORMAT
+         * ///////////////////////////////////////////////////////////////////////
+         *    [xhead]
+         *    2 major
+         *    2 minor
+         *    4 type    // bzip,tzip
+         *    [mszip_master_head]
+         *    4 unkn    // checksum?
+         *    2 unkn    // flags? (seems to be constant)
+         *    [mszip_head]
+         *    2 ofs     // offset to next section
+         *    2 magic   // 'CK'
+         *    ... ofs bytes of data
+         *    ... next mszip_head
+         *
+         *  http://www.kdedevelopers.org/node/3181 has been very helpful.
+         * ///////////////////////////////////////////////////////////////////////
+         */
+
+        // skip unknown data (checksum, flags?)
+        mP += 6;
+
+        // First find out how much storage we'll need. Count sections.
+        const char *P1 = mP;
+        unsigned int est_out = 0;
+
+        while (P1 + 3 < mEnd) {
+            // read next offset
+            uint16_t ofs = *((uint16_t *)P1);
+            AI_SWAP2(ofs);
+            P1 += 2;
+
+            if (ofs >= MSZIP_BLOCK)
+                throw DeadlyImportError("X: Invalid offset to next MSZIP compressed block");
+
+            // check magic word
+            uint16_t magic = *((uint16_t *)P1);
+            AI_SWAP2(magic);
+            P1 += 2;
+
+            if (magic != MSZIP_MAGIC)
+                throw DeadlyImportError("X: Unsupported compressed format, expected MSZIP header");
+
+            // and advance to the next offset
+            P1 += ofs;
+            est_out += MSZIP_BLOCK; // one decompressed block is 327861 in size
+        }
+        
+        // Allocate storage and terminating zero and do the actual uncompressing
+        Compression compression;
+        uncompressed.resize(est_out + 1);
+        char *out = &uncompressed.front();
+        if (compression.open(mIsBinaryFormat ? Compression::Format::Binary : Compression::Format::ASCII,
+                Compression::FlushMode::SyncFlush, -Compression::MaxWBits)) {
+            while (mP + 3 < mEnd) {
+                uint16_t ofs = *((uint16_t *)mP);
+                AI_SWAP2(ofs);
+                mP += 4;
+
+                if (mP + ofs > mEnd + 2) {
+                    throw DeadlyImportError("X: Unexpected EOF in compressed chunk");
+                }
+                out += compression.decompressBlock(mP, ofs, out, MSZIP_BLOCK);
+                mP += ofs;
+            }
+            compression.close();
+        }
+
+        // ok, update pointers to point to the uncompressed file data
+        mP = &uncompressed[0];
+        mEnd = out;
+
+        // FIXME: we don't need the compressed data anymore, could release
+        // it already for better memory usage. Consider breaking const-co.
+        ASSIMP_LOG_INFO("Successfully decompressed MSZIP-compressed file");
+#endif // !! ASSIMP_BUILD_NO_COMPRESSED_X
+    } else {
+        // start reading here
+        ReadUntilEndOfLine();
+    }
+
+    mScene = new Scene;
+    ParseFile();
+
+    // filter the imported hierarchy for some degenerated cases
+    if (mScene->mRootNode) {
+        FilterHierarchy(mScene->mRootNode);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor. Destroys all imported data along with it
+XFileParser::~XFileParser() {
+    // kill everything we created
+    delete mScene;
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseFile() {
+    bool running = true;
+    while (running) {
+        // read name of next object
+        std::string objectName = GetNextToken();
+        if (objectName.length() == 0) {
+            break;
+        }
+
+        // parse specific object
+        if (objectName == "template") {
+            ParseDataObjectTemplate();
+        } else if (objectName == "Frame") {
+            ParseDataObjectFrame(nullptr);
+        } else if (objectName == "Mesh") {
+            // some meshes have no frames at all
+            Mesh *mesh = new Mesh;
+            ParseDataObjectMesh(mesh);
+            mScene->mGlobalMeshes.push_back(mesh);
+        } else if (objectName == "AnimTicksPerSecond")
+            ParseDataObjectAnimTicksPerSecond();
+        else if (objectName == "AnimationSet")
+            ParseDataObjectAnimationSet();
+        else if (objectName == "Material") {
+            // Material outside of a mesh or node
+            Material material;
+            ParseDataObjectMaterial(&material);
+            mScene->mGlobalMaterials.push_back(material);
+        } else if (objectName == "}") {
+            // whatever?
+            ASSIMP_LOG_WARN("} found in dataObject");
+        } else {
+            // unknown format
+            ASSIMP_LOG_WARN("Unknown data object in animation of .x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectTemplate() {
+    // parse a template data object. Currently not stored.
+    std::string name;
+    readHeadOfDataObject(&name);
+
+    // read GUID
+    std::string guid = GetNextToken();
+
+    // read and ignore data members
+    bool running = true;
+    while (running) {
+        std::string s = GetNextToken();
+
+        if (s == "}") {
+            break;
+        }
+
+        if (s.length() == 0) {
+            ThrowException("Unexpected end of file reached while parsing template definition");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectFrame(Node *pParent) {
+    // A coordinate frame, or "frame of reference." The Frame template
+    // is open and can contain any object. The Direct3D extensions (D3DX)
+    // mesh-loading functions recognize Mesh, FrameTransformMatrix, and
+    // Frame template instances as child objects when loading a Frame
+    // instance.
+    std::string name;
+    readHeadOfDataObject(&name);
+
+    // create a named node and place it at its parent, if given
+    Node *node = new Node(pParent);
+    node->mName = name;
+    if (pParent) {
+        pParent->mChildren.push_back(node);
+    } else {
+        // there might be multiple root nodes
+        if (mScene->mRootNode != nullptr) {
+            // place a dummy root if not there
+            if (mScene->mRootNode->mName != "$dummy_root") {
+                Node *exroot = mScene->mRootNode;
+                mScene->mRootNode = new Node(nullptr);
+                mScene->mRootNode->mName = "$dummy_root";
+                mScene->mRootNode->mChildren.push_back(exroot);
+                exroot->mParent = mScene->mRootNode;
+            }
+            // put the new node as its child instead
+            mScene->mRootNode->mChildren.push_back(node);
+            node->mParent = mScene->mRootNode;
+        } else {
+            // it's the first node imported. place it as root
+            mScene->mRootNode = node;
+        }
+    }
+
+    // Now inside a frame.
+    // read tokens until closing brace is reached.
+    bool running = true;
+    while (running) {
+        std::string objectName = GetNextToken();
+        if (objectName.size() == 0)
+            ThrowException("Unexpected end of file reached while parsing frame");
+
+        if (objectName == "}")
+            break; // frame finished
+        else if (objectName == "Frame")
+            ParseDataObjectFrame(node); // child frame
+        else if (objectName == "FrameTransformMatrix")
+            ParseDataObjectTransformationMatrix(node->mTrafoMatrix);
+        else if (objectName == "Mesh") {
+            Mesh *mesh = new Mesh(name);
+            node->mMeshes.push_back(mesh);
+            ParseDataObjectMesh(mesh);
+        } else {
+            ASSIMP_LOG_WARN("Unknown data object in frame in x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectTransformationMatrix(aiMatrix4x4 &pMatrix) {
+    // read header, we're not interested if it has a name
+    readHeadOfDataObject();
+
+    // read its components
+    pMatrix.a1 = ReadFloat();
+    pMatrix.b1 = ReadFloat();
+    pMatrix.c1 = ReadFloat();
+    pMatrix.d1 = ReadFloat();
+    pMatrix.a2 = ReadFloat();
+    pMatrix.b2 = ReadFloat();
+    pMatrix.c2 = ReadFloat();
+    pMatrix.d2 = ReadFloat();
+    pMatrix.a3 = ReadFloat();
+    pMatrix.b3 = ReadFloat();
+    pMatrix.c3 = ReadFloat();
+    pMatrix.d3 = ReadFloat();
+    pMatrix.a4 = ReadFloat();
+    pMatrix.b4 = ReadFloat();
+    pMatrix.c4 = ReadFloat();
+    pMatrix.d4 = ReadFloat();
+
+    // trailing symbols
+    CheckForSemicolon();
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectMesh(Mesh *pMesh) {
+    std::string name;
+    readHeadOfDataObject(&name);
+
+    // read vertex count
+    unsigned int numVertices = ReadInt();
+    pMesh->mPositions.resize(numVertices);
+
+    // read vertices
+    for (unsigned int a = 0; a < numVertices; a++)
+        pMesh->mPositions[a] = ReadVector3();
+
+    // read position faces
+    unsigned int numPosFaces = ReadInt();
+    pMesh->mPosFaces.resize(numPosFaces);
+    for (unsigned int a = 0; a < numPosFaces; ++a) {
+        // read indices
+        unsigned int numIndices = ReadInt();
+        Face &face = pMesh->mPosFaces[a];
+        for (unsigned int b = 0; b < numIndices; ++b) {
+            const int idx(ReadInt());
+            if (static_cast<unsigned int>(idx) <= numVertices) {
+                face.mIndices.push_back(idx);
+            }
+        }
+        TestForSeparator();
+    }
+
+    // here, other data objects may follow
+    bool running = true;
+    while (running) {
+        std::string objectName = GetNextToken();
+
+        if (objectName.empty())
+            ThrowException("Unexpected end of file while parsing mesh structure");
+        else if (objectName == "}")
+            break; // mesh finished
+        else if (objectName == "MeshNormals")
+            ParseDataObjectMeshNormals(pMesh);
+        else if (objectName == "MeshTextureCoords")
+            ParseDataObjectMeshTextureCoords(pMesh);
+        else if (objectName == "MeshVertexColors")
+            ParseDataObjectMeshVertexColors(pMesh);
+        else if (objectName == "MeshMaterialList")
+            ParseDataObjectMeshMaterialList(pMesh);
+        else if (objectName == "VertexDuplicationIndices")
+            ParseUnknownDataObject(); // we'll ignore vertex duplication indices
+        else if (objectName == "XSkinMeshHeader")
+            ParseDataObjectSkinMeshHeader(pMesh);
+        else if (objectName == "SkinWeights")
+            ParseDataObjectSkinWeights(pMesh);
+        else {
+            ASSIMP_LOG_WARN("Unknown data object in mesh in x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectSkinWeights(Mesh *pMesh) {
+    if (nullptr == pMesh) {
+        return;
+    }
+    readHeadOfDataObject();
+
+    std::string transformNodeName;
+    GetNextTokenAsString(transformNodeName);
+
+    pMesh->mBones.push_back(Bone());
+    Bone &bone = pMesh->mBones.back();
+    bone.mName = transformNodeName;
+
+    // read vertex weights
+    unsigned int numWeights = ReadInt();
+    bone.mWeights.reserve(numWeights);
+
+    for (unsigned int a = 0; a < numWeights; a++) {
+        BoneWeight weight = {};
+        weight.mVertex = ReadInt();
+        bone.mWeights.push_back(weight);
+    }
+
+    // read vertex weights
+    for (unsigned int a = 0; a < numWeights; a++)
+        bone.mWeights[a].mWeight = ReadFloat();
+
+    // read matrix offset
+    bone.mOffsetMatrix.a1 = ReadFloat();
+    bone.mOffsetMatrix.b1 = ReadFloat();
+    bone.mOffsetMatrix.c1 = ReadFloat();
+    bone.mOffsetMatrix.d1 = ReadFloat();
+    bone.mOffsetMatrix.a2 = ReadFloat();
+    bone.mOffsetMatrix.b2 = ReadFloat();
+    bone.mOffsetMatrix.c2 = ReadFloat();
+    bone.mOffsetMatrix.d2 = ReadFloat();
+    bone.mOffsetMatrix.a3 = ReadFloat();
+    bone.mOffsetMatrix.b3 = ReadFloat();
+    bone.mOffsetMatrix.c3 = ReadFloat();
+    bone.mOffsetMatrix.d3 = ReadFloat();
+    bone.mOffsetMatrix.a4 = ReadFloat();
+    bone.mOffsetMatrix.b4 = ReadFloat();
+    bone.mOffsetMatrix.c4 = ReadFloat();
+    bone.mOffsetMatrix.d4 = ReadFloat();
+
+    CheckForSemicolon();
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectSkinMeshHeader(Mesh * /*pMesh*/) {
+    readHeadOfDataObject();
+
+    /*unsigned int maxSkinWeightsPerVertex =*/ReadInt();
+    /*unsigned int maxSkinWeightsPerFace =*/ReadInt();
+    /*unsigned int numBonesInMesh = */ ReadInt();
+
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectMeshNormals(Mesh *pMesh) {
+    readHeadOfDataObject();
+
+    // read count
+    unsigned int numNormals = ReadInt();
+    pMesh->mNormals.resize(numNormals);
+
+    // read normal vectors
+    for (unsigned int a = 0; a < numNormals; ++a) {
+        pMesh->mNormals[a] = ReadVector3();
+    }
+
+    // read normal indices
+    unsigned int numFaces = ReadInt();
+    if (numFaces != pMesh->mPosFaces.size()) {
+        ThrowException("Normal face count does not match vertex face count.");
+    }
+
+    // do not crah when no face definitions are there
+    if (numFaces > 0) {
+        // normal face creation
+        pMesh->mNormFaces.resize(numFaces);
+        for (unsigned int a = 0; a < numFaces; ++a) {
+            unsigned int numIndices = ReadInt();
+            pMesh->mNormFaces[a] = Face();
+            Face &face = pMesh->mNormFaces[a];
+            for (unsigned int b = 0; b < numIndices; ++b) {
+                face.mIndices.push_back(ReadInt());
+            }
+
+            TestForSeparator();
+        }
+    }
+
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectMeshTextureCoords(Mesh *pMesh) {
+    readHeadOfDataObject();
+    if (pMesh->mNumTextures + 1 > AI_MAX_NUMBER_OF_TEXTURECOORDS)
+        ThrowException("Too many sets of texture coordinates");
+
+    std::vector<aiVector2D> &coords = pMesh->mTexCoords[pMesh->mNumTextures++];
+
+    unsigned int numCoords = ReadInt();
+    if (numCoords != pMesh->mPositions.size())
+        ThrowException("Texture coord count does not match vertex count");
+
+    coords.resize(numCoords);
+    for (unsigned int a = 0; a < numCoords; a++)
+        coords[a] = ReadVector2();
+
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectMeshVertexColors(Mesh *pMesh) {
+    readHeadOfDataObject();
+    if (pMesh->mNumColorSets + 1 > AI_MAX_NUMBER_OF_COLOR_SETS)
+        ThrowException("Too many colorsets");
+    std::vector<aiColor4D> &colors = pMesh->mColors[pMesh->mNumColorSets++];
+
+    unsigned int numColors = ReadInt();
+    if (numColors != pMesh->mPositions.size())
+        ThrowException("Vertex color count does not match vertex count");
+
+    colors.resize(numColors, aiColor4D(0, 0, 0, 1));
+    for (unsigned int a = 0; a < numColors; a++) {
+        unsigned int index = ReadInt();
+        if (index >= pMesh->mPositions.size())
+            ThrowException("Vertex color index out of bounds");
+
+        colors[index] = ReadRGBA();
+        // HACK: (thom) Maxon Cinema XPort plugin puts a third separator here, kwxPort puts a comma.
+        // Ignore gracefully.
+        if (!mIsBinaryFormat) {
+            FindNextNoneWhiteSpace();
+            if (*mP == ';' || *mP == ',')
+                mP++;
+        }
+    }
+
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectMeshMaterialList(Mesh *pMesh) {
+    readHeadOfDataObject();
+
+    // read material count
+    /*unsigned int numMaterials =*/ReadInt();
+    // read non triangulated face material index count
+    unsigned int numMatIndices = ReadInt();
+
+    // some models have a material index count of 1... to be able to read them we
+    // replicate this single material index on every face
+    if (numMatIndices != pMesh->mPosFaces.size() && numMatIndices != 1)
+        ThrowException("Per-Face material index count does not match face count.");
+
+    // read per-face material indices
+    for (unsigned int a = 0; a < numMatIndices; a++)
+        pMesh->mFaceMaterials.push_back(ReadInt());
+
+    // in version 03.02, the face indices end with two semicolons.
+    // commented out version check, as version 03.03 exported from blender also has 2 semicolons
+    if (!mIsBinaryFormat) // && MajorVersion == 3 && MinorVersion <= 2)
+    {
+        if (mP < mEnd && *mP == ';')
+            ++mP;
+    }
+
+    // if there was only a single material index, replicate it on all faces
+    while (pMesh->mFaceMaterials.size() < pMesh->mPosFaces.size())
+        pMesh->mFaceMaterials.push_back(pMesh->mFaceMaterials.front());
+
+    // read following data objects
+    bool running = true;
+    while (running) {
+        std::string objectName = GetNextToken();
+        if (objectName.size() == 0)
+            ThrowException("Unexpected end of file while parsing mesh material list.");
+        else if (objectName == "}")
+            break; // material list finished
+        else if (objectName == "{") {
+            // template materials
+            std::string matName = GetNextToken();
+            Material material;
+            material.mIsReference = true;
+            material.mName = matName;
+            pMesh->mMaterials.push_back(material);
+
+            CheckForClosingBrace(); // skip }
+        } else if (objectName == "Material") {
+            pMesh->mMaterials.push_back(Material());
+            ParseDataObjectMaterial(&pMesh->mMaterials.back());
+        } else if (objectName == ";") {
+            // ignore
+        } else {
+            ASSIMP_LOG_WARN("Unknown data object in material list in x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectMaterial(Material *pMaterial) {
+    std::string matName;
+    readHeadOfDataObject(&matName);
+    if (matName.empty())
+        matName = std::string("material") + ai_to_string(mLineNumber);
+    pMaterial->mName = matName;
+    pMaterial->mIsReference = false;
+
+    // read material values
+    pMaterial->mDiffuse = ReadRGBA();
+    pMaterial->mSpecularExponent = ReadFloat();
+    pMaterial->mSpecular = ReadRGB();
+    pMaterial->mEmissive = ReadRGB();
+
+    // read other data objects
+    bool running = true;
+    while (running) {
+        std::string objectName = GetNextToken();
+        if (objectName.size() == 0)
+            ThrowException("Unexpected end of file while parsing mesh material");
+        else if (objectName == "}")
+            break; // material finished
+        else if (objectName == "TextureFilename" || objectName == "TextureFileName") {
+            // some exporters write "TextureFileName" instead.
+            std::string texname;
+            ParseDataObjectTextureFilename(texname);
+            pMaterial->mTextures.push_back(TexEntry(texname));
+        } else if (objectName == "NormalmapFilename" || objectName == "NormalmapFileName") {
+            // one exporter writes out the normal map in a separate filename tag
+            std::string texname;
+            ParseDataObjectTextureFilename(texname);
+            pMaterial->mTextures.push_back(TexEntry(texname, true));
+        } else {
+            ASSIMP_LOG_WARN("Unknown data object in material in x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectAnimTicksPerSecond() {
+    readHeadOfDataObject();
+    mScene->mAnimTicksPerSecond = ReadInt();
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectAnimationSet() {
+    std::string animName;
+    readHeadOfDataObject(&animName);
+
+    Animation *anim = new Animation;
+    mScene->mAnims.push_back(anim);
+    anim->mName = animName;
+
+    bool running = true;
+    while (running) {
+        std::string objectName = GetNextToken();
+        if (objectName.length() == 0)
+            ThrowException("Unexpected end of file while parsing animation set.");
+        else if (objectName == "}")
+            break; // animation set finished
+        else if (objectName == "Animation")
+            ParseDataObjectAnimation(anim);
+        else {
+            ASSIMP_LOG_WARN("Unknown data object in animation set in x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectAnimation(Animation *pAnim) {
+    readHeadOfDataObject();
+    AnimBone *banim = new AnimBone;
+    pAnim->mAnims.push_back(banim);
+
+    bool running = true;
+    while (running) {
+        std::string objectName = GetNextToken();
+
+        if (objectName.length() == 0)
+            ThrowException("Unexpected end of file while parsing animation.");
+        else if (objectName == "}")
+            break; // animation finished
+        else if (objectName == "AnimationKey")
+            ParseDataObjectAnimationKey(banim);
+        else if (objectName == "AnimationOptions")
+            ParseUnknownDataObject(); // not interested
+        else if (objectName == "{") {
+            // read frame name
+            banim->mBoneName = GetNextToken();
+            CheckForClosingBrace();
+        } else {
+            ASSIMP_LOG_WARN("Unknown data object in animation in x file");
+            ParseUnknownDataObject();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectAnimationKey(AnimBone *pAnimBone) {
+    readHeadOfDataObject();
+
+    // read key type
+    unsigned int keyType = ReadInt();
+
+    // read number of keys
+    unsigned int numKeys = ReadInt();
+
+    for (unsigned int a = 0; a < numKeys; a++) {
+        // read time
+        unsigned int time = ReadInt();
+
+        // read keys
+        switch (keyType) {
+        case 0: // rotation quaternion
+        {
+            // read count
+            if (ReadInt() != 4)
+                ThrowException("Invalid number of arguments for quaternion key in animation");
+
+            aiQuatKey key;
+            key.mTime = double(time);
+            key.mValue.w = ReadFloat();
+            key.mValue.x = ReadFloat();
+            key.mValue.y = ReadFloat();
+            key.mValue.z = ReadFloat();
+            pAnimBone->mRotKeys.push_back(key);
+
+            CheckForSemicolon();
+            break;
+        }
+
+        case 1: // scale vector
+        case 2: // position vector
+        {
+            // read count
+            if (ReadInt() != 3)
+                ThrowException("Invalid number of arguments for vector key in animation");
+
+            aiVectorKey key;
+            key.mTime = double(time);
+            key.mValue = ReadVector3();
+
+            if (keyType == 2)
+                pAnimBone->mPosKeys.push_back(key);
+            else
+                pAnimBone->mScaleKeys.push_back(key);
+
+            break;
+        }
+
+        case 3: // combined transformation matrix
+        case 4: // denoted both as 3 or as 4
+        {
+            // read count
+            if (ReadInt() != 16)
+                ThrowException("Invalid number of arguments for matrix key in animation");
+
+            // read matrix
+            MatrixKey key;
+            key.mTime = double(time);
+            key.mMatrix.a1 = ReadFloat();
+            key.mMatrix.b1 = ReadFloat();
+            key.mMatrix.c1 = ReadFloat();
+            key.mMatrix.d1 = ReadFloat();
+            key.mMatrix.a2 = ReadFloat();
+            key.mMatrix.b2 = ReadFloat();
+            key.mMatrix.c2 = ReadFloat();
+            key.mMatrix.d2 = ReadFloat();
+            key.mMatrix.a3 = ReadFloat();
+            key.mMatrix.b3 = ReadFloat();
+            key.mMatrix.c3 = ReadFloat();
+            key.mMatrix.d3 = ReadFloat();
+            key.mMatrix.a4 = ReadFloat();
+            key.mMatrix.b4 = ReadFloat();
+            key.mMatrix.c4 = ReadFloat();
+            key.mMatrix.d4 = ReadFloat();
+            pAnimBone->mTrafoKeys.push_back(key);
+
+            CheckForSemicolon();
+            break;
+        }
+
+        default:
+            ThrowException("Unknown key type ", keyType, " in animation.");
+            break;
+        } // end switch
+
+        // key separator
+        CheckForSeparator();
+    }
+
+    CheckForClosingBrace();
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseDataObjectTextureFilename(std::string &pName) {
+    readHeadOfDataObject();
+    GetNextTokenAsString(pName);
+    CheckForClosingBrace();
+
+    // FIX: some files (e.g. AnimationTest.x) have "" as texture file name
+    if (!pName.length()) {
+        ASSIMP_LOG_WARN("Length of texture file name is zero. Skipping this texture.");
+    }
+
+    // some exporters write double backslash paths out. We simply replace them if we find them
+    while (pName.find("\\\\") != std::string::npos)
+        pName.replace(pName.find("\\\\"), 2, "\\");
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ParseUnknownDataObject() {
+    // find opening delimiter
+    bool running = true;
+    while (running) {
+        std::string t = GetNextToken();
+        if (t.length() == 0)
+            ThrowException("Unexpected end of file while parsing unknown segment.");
+
+        if (t == "{")
+            break;
+    }
+
+    unsigned int counter = 1;
+
+    // parse until closing delimiter
+    while (counter > 0) {
+        std::string t = GetNextToken();
+
+        if (t.length() == 0)
+            ThrowException("Unexpected end of file while parsing unknown segment.");
+
+        if (t == "{")
+            ++counter;
+        else if (t == "}")
+            --counter;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//! checks for closing curly brace
+void XFileParser::CheckForClosingBrace() {
+    if (GetNextToken() != "}")
+        ThrowException("Closing brace expected.");
+}
+
+// ------------------------------------------------------------------------------------------------
+//! checks for one following semicolon
+void XFileParser::CheckForSemicolon() {
+    if (mIsBinaryFormat)
+        return;
+
+    if (GetNextToken() != ";")
+        ThrowException("Semicolon expected.");
+}
+
+// ------------------------------------------------------------------------------------------------
+//! checks for a separator char, either a ',' or a ';'
+void XFileParser::CheckForSeparator() {
+    if (mIsBinaryFormat)
+        return;
+
+    std::string token = GetNextToken();
+    if (token != "," && token != ";")
+        ThrowException("Separator character (';' or ',') expected.");
+}
+
+// ------------------------------------------------------------------------------------------------
+// tests and possibly consumes a separator char, but does nothing if there was no separator
+void XFileParser::TestForSeparator() {
+    if (mIsBinaryFormat)
+        return;
+
+    FindNextNoneWhiteSpace();
+    if (mP >= mEnd)
+        return;
+
+    // test and skip
+    if (*mP == ';' || *mP == ',')
+        mP++;
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::readHeadOfDataObject(std::string *poName) {
+    std::string nameOrBrace = GetNextToken();
+    if (nameOrBrace != "{") {
+        if (poName)
+            *poName = nameOrBrace;
+
+        if (GetNextToken() != "{") {
+            delete mScene;
+            ThrowException("Opening brace expected.");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+std::string XFileParser::GetNextToken() {
+    std::string s;
+
+    // process binary-formatted file
+    if (mIsBinaryFormat) {
+        // in binary mode it will only return NAME and STRING token
+        // and (correctly) skip over other tokens.
+        if (mEnd - mP < 2) {
+            return s;
+        }
+        unsigned int tok = ReadBinWord();
+        unsigned int len;
+
+        // standalone tokens
+        switch (tok) {
+        case 1: {
+            // name token
+            if (mEnd - mP < 4) {
+                return s;
+            }
+            len = ReadBinDWord();
+            const int bounds = int(mEnd - mP);
+            const int iLen = int(len);
+            if (iLen < 0) {
+                return s;
+            }
+            if (bounds < iLen) {
+                return s;
+            }
+            s = std::string(mP, len);
+            mP += len;
+        }
+            return s;
+
+        case 2:
+            // string token
+            if (mEnd - mP < 4) return s;
+            len = ReadBinDWord();
+            if (mEnd - mP < int(len)) return s;
+            s = std::string(mP, len);
+            mP += (len + 2);
+            return s;
+        case 3:
+            // integer token
+            mP += 4;
+            return "<integer>";
+        case 5:
+            // GUID token
+            mP += 16;
+            return "<guid>";
+        case 6:
+            if (mEnd - mP < 4) return s;
+            len = ReadBinDWord();
+            mP += (len * 4);
+            return "<int_list>";
+        case 7:
+            if (mEnd - mP < 4) return s;
+            len = ReadBinDWord();
+            mP += (len * mBinaryFloatSize);
+            return "<flt_list>";
+        case 0x0a:
+            return "{";
+        case 0x0b:
+            return "}";
+        case 0x0c:
+            return "(";
+        case 0x0d:
+            return ")";
+        case 0x0e:
+            return "[";
+        case 0x0f:
+            return "]";
+        case 0x10:
+            return "<";
+        case 0x11:
+            return ">";
+        case 0x12:
+            return ".";
+        case 0x13:
+            return ",";
+        case 0x14:
+            return ";";
+        case 0x1f:
+            return "template";
+        case 0x28:
+            return "WORD";
+        case 0x29:
+            return "DWORD";
+        case 0x2a:
+            return "FLOAT";
+        case 0x2b:
+            return "DOUBLE";
+        case 0x2c:
+            return "CHAR";
+        case 0x2d:
+            return "UCHAR";
+        case 0x2e:
+            return "SWORD";
+        case 0x2f:
+            return "SDWORD";
+        case 0x30:
+            return "void";
+        case 0x31:
+            return "string";
+        case 0x32:
+            return "unicode";
+        case 0x33:
+            return "cstring";
+        case 0x34:
+            return "array";
+        }
+    }
+    // process text-formatted file
+    else {
+        FindNextNoneWhiteSpace();
+        if (mP >= mEnd)
+            return s;
+
+        while ((mP < mEnd) && !isspace((unsigned char)*mP)) {
+            // either keep token delimiters when already holding a token, or return if first valid char
+            if (*mP == ';' || *mP == '}' || *mP == '{' || *mP == ',') {
+                if (!s.size())
+                    s.append(mP++, 1);
+                break; // stop for delimiter
+            }
+            s.append(mP++, 1);
+        }
+    }
+    return s;
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::FindNextNoneWhiteSpace() {
+    if (mIsBinaryFormat)
+        return;
+
+    bool running = true;
+    while (running) {
+        while (mP < mEnd && isspace((unsigned char)*mP)) {
+            if (*mP == '\n')
+                mLineNumber++;
+            ++mP;
+        }
+
+        if (mP >= mEnd)
+            return;
+
+        // check if this is a comment
+        if ((mP[0] == '/' && mP[1] == '/') || mP[0] == '#')
+            ReadUntilEndOfLine();
+        else
+            break;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::GetNextTokenAsString(std::string &poString) {
+    if (mIsBinaryFormat) {
+        poString = GetNextToken();
+        return;
+    }
+
+    FindNextNoneWhiteSpace();
+    if (mP >= mEnd) {
+        delete mScene;
+        ThrowException("Unexpected end of file while parsing string");
+    }
+
+    if (*mP != '"') {
+        delete mScene;
+        ThrowException("Expected quotation mark.");
+    }
+    ++mP;
+
+    while (mP < mEnd && *mP != '"')
+        poString.append(mP++, 1);
+
+    if (mP >= mEnd - 1) {
+        delete mScene;
+        ThrowException("Unexpected end of file while parsing string");
+    }
+
+    if (mP[1] != ';' || mP[0] != '"') {
+        delete mScene;
+        ThrowException("Expected quotation mark and semicolon at the end of a string.");
+    }
+    mP += 2;
+}
+
+// ------------------------------------------------------------------------------------------------
+void XFileParser::ReadUntilEndOfLine() {
+    if (mIsBinaryFormat)
+        return;
+
+    while (mP < mEnd) {
+        if (*mP == '\n' || *mP == '\r') {
+            ++mP;
+            mLineNumber++;
+            return;
+        }
+
+        ++mP;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned short XFileParser::ReadBinWord() {
+    ai_assert(mEnd - mP >= 2);
+    const unsigned char *q = (const unsigned char *)mP;
+    unsigned short tmp = q[0] | (q[1] << 8);
+    mP += 2;
+    return tmp;
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned int XFileParser::ReadBinDWord() {
+    ai_assert(mEnd - mP >= 4);
+
+    const unsigned char *q = (const unsigned char *)mP;
+    unsigned int tmp = q[0] | (q[1] << 8) | (q[2] << 16) | (q[3] << 24);
+    mP += 4;
+    return tmp;
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned int XFileParser::ReadInt() {
+    if (mIsBinaryFormat) {
+        if (mBinaryNumCount == 0 && mEnd - mP >= 2) {
+            unsigned short tmp = ReadBinWord(); // 0x06 or 0x03
+            if (tmp == 0x06 && mEnd - mP >= 4) // array of ints follows
+                mBinaryNumCount = ReadBinDWord();
+            else // single int follows
+                mBinaryNumCount = 1;
+        }
+
+        --mBinaryNumCount;
+        const size_t len(mEnd - mP);
+        if (len >= 4) {
+            return ReadBinDWord();
+        } else {
+            mP = mEnd;
+            return 0;
+        }
+    } else {
+        FindNextNoneWhiteSpace();
+
+        // TODO: consider using strtol10 instead???
+
+        // check preceding minus sign
+        bool isNegative = false;
+        if (*mP == '-') {
+            isNegative = true;
+            mP++;
+        }
+
+        // at least one digit expected
+        if (!isdigit((unsigned char)*mP))
+            ThrowException("Number expected.");
+
+        // read digits
+        unsigned int number = 0;
+        while (mP < mEnd) {
+            if (!isdigit((unsigned char)*mP))
+                break;
+            number = number * 10 + (*mP - 48);
+            mP++;
+        }
+
+        CheckForSeparator();
+
+        return isNegative ? ((unsigned int)-int(number)) : number;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+ai_real XFileParser::ReadFloat() {
+    if (mIsBinaryFormat) {
+        if (mBinaryNumCount == 0 && mEnd - mP >= 2) {
+            unsigned short tmp = ReadBinWord(); // 0x07 or 0x42
+            if (tmp == 0x07 && mEnd - mP >= 4) // array of floats following
+                mBinaryNumCount = ReadBinDWord();
+            else // single float following
+                mBinaryNumCount = 1;
+        }
+
+        --mBinaryNumCount;
+        if (mBinaryFloatSize == 8) {
+            if (mEnd - mP >= 8) {
+                double res;
+                ::memcpy(&res, mP, 8);
+                mP += 8;
+                const ai_real result(static_cast<ai_real>(res));
+                return result;
+            } else {
+                mP = mEnd;
+                return 0;
+            }
+        } else {
+            if (mEnd - mP >= 4) {
+                ai_real result;
+                ::memcpy(&result, mP, 4);
+                mP += 4;
+                return result;
+            } else {
+                mP = mEnd;
+                return 0;
+            }
+        }
+    }
+
+    // text version
+    FindNextNoneWhiteSpace();
+    // check for various special strings to allow reading files from faulty exporters
+    // I mean you, Blender!
+    // Reading is safe because of the terminating zero
+    if (strncmp(mP, "-1.#IND00", 9) == 0 || strncmp(mP, "1.#IND00", 8) == 0) {
+        mP += 9;
+        CheckForSeparator();
+        return 0.0;
+    } else if (strncmp(mP, "1.#QNAN0", 8) == 0) {
+        mP += 8;
+        CheckForSeparator();
+        return 0.0;
+    }
+
+    ai_real result = 0.0;
+    mP = fast_atoreal_move<ai_real>(mP, result);
+
+    CheckForSeparator();
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector2D XFileParser::ReadVector2() {
+    aiVector2D vector;
+    vector.x = ReadFloat();
+    vector.y = ReadFloat();
+    TestForSeparator();
+
+    return vector;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector3D XFileParser::ReadVector3() {
+    aiVector3D vector;
+    vector.x = ReadFloat();
+    vector.y = ReadFloat();
+    vector.z = ReadFloat();
+    TestForSeparator();
+
+    return vector;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiColor4D XFileParser::ReadRGBA() {
+    aiColor4D color;
+    color.r = ReadFloat();
+    color.g = ReadFloat();
+    color.b = ReadFloat();
+    color.a = ReadFloat();
+    TestForSeparator();
+
+    return color;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiColor3D XFileParser::ReadRGB() {
+    aiColor3D color;
+    color.r = ReadFloat();
+    color.g = ReadFloat();
+    color.b = ReadFloat();
+    TestForSeparator();
+
+    return color;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Filters the imported hierarchy for some degenerated cases that some exporters produce.
+void XFileParser::FilterHierarchy(XFile::Node *pNode) {
+    // if the node has just a single unnamed child containing a mesh, remove
+    // the anonymous node between. The 3DSMax kwXport plugin seems to produce this
+    // mess in some cases
+    if (pNode->mChildren.size() == 1 && pNode->mMeshes.empty()) {
+        XFile::Node *child = pNode->mChildren.front();
+        if (child->mName.length() == 0 && child->mMeshes.size() > 0) {
+            // transfer its meshes to us
+            for (unsigned int a = 0; a < child->mMeshes.size(); a++)
+                pNode->mMeshes.push_back(child->mMeshes[a]);
+            child->mMeshes.clear();
+
+            // transfer the transform as well
+            pNode->mTrafoMatrix = pNode->mTrafoMatrix * child->mTrafoMatrix;
+
+            // then kill it
+            delete child;
+            pNode->mChildren.clear();
+        }
+    }
+
+    // recurse
+    for (unsigned int a = 0; a < pNode->mChildren.size(); a++)
+        FilterHierarchy(pNode->mChildren[a]);
+}
+
+#endif // !! ASSIMP_BUILD_NO_X_IMPORTER