add assimp submodule

8 files changed, 7610 insertions, 0 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp
new file mode 100644
index 0000000..5c91daa
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp
@@ -0,0 +1,1748 @@
+/*
+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.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
+
+#include "ColladaExporter.h"
+
+#include <assimp/Bitmap.h>
+#include <assimp/ColladaMetaData.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/Exceptional.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XMLTools.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/scene.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <ctime>
+#include <memory>
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
+void ExportSceneCollada(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
+    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
+
+    // invoke the exporter
+    ColladaExporter iDoTheExportThing(pScene, pIOSystem, path, file);
+
+    if (iDoTheExportThing.mOutput.fail()) {
+        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
+    }
+
+    // we're still here - export successfully completed. Write result to the given IOSYstem
+    std::unique_ptr<IOStream> outfile(pIOSystem->Open(pFile, "wt"));
+    if (outfile == nullptr) {
+        throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
+    }
+
+    // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
+    outfile->Write(iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()), 1);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
+static const std::string XMLIDEncode(const std::string &name) {
+    const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
+    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
+
+    if (name.length() == 0) {
+        return name;
+    }
+
+    std::stringstream idEncoded;
+
+    // xsd:ID must start with letter or underscore
+    if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) {
+        idEncoded << '_';
+    }
+
+    for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) {
+        // xsd:ID can only contain letters, digits, underscores, hyphens and periods
+        if (strchr(XML_ID_CHARS, *it) != nullptr) {
+            idEncoded << *it;
+        } else {
+            // Select placeholder character based on invalid character to reduce ID collisions
+            idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT];
+        }
+    }
+
+    return idEncoded.str();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Helper functions to create unique ids
+inline bool IsUniqueId(const std::unordered_set<std::string> &idSet, const std::string &idStr) {
+    return (idSet.find(idStr) == idSet.end());
+}
+
+inline std::string MakeUniqueId(const std::unordered_set<std::string> &idSet, const std::string &idPrefix, const std::string &postfix) {
+    std::string result(idPrefix + postfix);
+    if (!IsUniqueId(idSet, result)) {
+        // Select a number to append
+        size_t idnum = 1;
+        do {
+            result = idPrefix + '_' + ai_to_string(idnum) + postfix;
+            ++idnum;
+        } while (!IsUniqueId(idSet, result));
+    }
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor for a specific scene to export
+ColladaExporter::ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file) :
+        mIOSystem(pIOSystem),
+        mPath(path),
+        mFile(file),
+        mScene(pScene),
+        endstr("\n") {
+    // make sure that all formatting happens using the standard, C locale and not the user's current locale
+    mOutput.imbue(std::locale("C"));
+    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+
+    // start writing the file
+    WriteFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor
+ColladaExporter::~ColladaExporter() {
+}
+
+// ------------------------------------------------------------------------------------------------
+// Starts writing the contents
+void ColladaExporter::WriteFile() {
+    // write the DTD
+    mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
+    // COLLADA element start
+    mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
+    PushTag();
+
+    WriteTextures();
+    WriteHeader();
+
+    // Add node names to the unique id database first so they are most likely to use their names as unique ids
+    CreateNodeIds(mScene->mRootNode);
+
+    WriteCamerasLibrary();
+    WriteLightsLibrary();
+    WriteMaterials();
+    WriteGeometryLibrary();
+    WriteControllerLibrary();
+
+    WriteSceneLibrary();
+
+    // customized, Writes the animation library
+    WriteAnimationsLibrary();
+
+    // instantiate the scene(s)
+    // For Assimp there will only ever be one
+    mOutput << startstr << "<scene>" << endstr;
+    PushTag();
+    mOutput << startstr << "<instance_visual_scene url=\"#" + mSceneId + "\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</scene>" << endstr;
+    PopTag();
+    mOutput << "</COLLADA>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the asset header
+void ColladaExporter::WriteHeader() {
+    static const ai_real epsilon = Math::getEpsilon<ai_real>();
+    static const aiQuaternion x_rot(aiMatrix3x3(
+            0, -1, 0,
+            1, 0, 0,
+            0, 0, 1));
+    static const aiQuaternion y_rot(aiMatrix3x3(
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1));
+    static const aiQuaternion z_rot(aiMatrix3x3(
+            1, 0, 0,
+            0, 0, 1,
+            0, -1, 0));
+
+    static const unsigned int date_nb_chars = 20;
+    char date_str[date_nb_chars];
+    std::time_t date = std::time(nullptr);
+    std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
+
+    aiVector3D scaling;
+    aiQuaternion rotation;
+    aiVector3D position;
+    mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
+    rotation.Normalize();
+
+    mAdd_root_node = false;
+
+    ai_real scale = 1.0;
+    if (std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
+        scale = (ai_real)((((double)scaling.x) + ((double)scaling.y) + ((double)scaling.z)) / 3.0);
+    } else {
+        mAdd_root_node = true;
+    }
+
+    std::string up_axis = "Y_UP";
+    if (rotation.Equal(x_rot, epsilon)) {
+        up_axis = "X_UP";
+    } else if (rotation.Equal(y_rot, epsilon)) {
+        up_axis = "Y_UP";
+    } else if (rotation.Equal(z_rot, epsilon)) {
+        up_axis = "Z_UP";
+    } else {
+        mAdd_root_node = true;
+    }
+
+    if (!position.Equal(aiVector3D(0, 0, 0))) {
+        mAdd_root_node = true;
+    }
+
+    // Assimp root nodes can have meshes, Collada Scenes cannot
+    if (mScene->mRootNode->mNumChildren == 0 || mScene->mRootNode->mMeshes != 0) {
+        mAdd_root_node = true;
+    }
+
+    if (mAdd_root_node) {
+        up_axis = "Y_UP";
+        scale = 1.0;
+    }
+
+    mOutput << startstr << "<asset>" << endstr;
+    PushTag();
+    mOutput << startstr << "<contributor>" << endstr;
+    PushTag();
+
+    // If no Scene metadata, use root node metadata
+    aiMetadata *meta = mScene->mMetaData;
+    if (nullptr == meta) {
+        meta = mScene->mRootNode->mMetaData;
+    }
+
+    aiString value;
+    if (!meta || !meta->Get("Author", value)) {
+        mOutput << startstr << "<author>"
+                << "Assimp"
+                << "</author>" << endstr;
+    } else {
+        mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
+    }
+
+    if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
+        mOutput << startstr << "<authoring_tool>"
+                << "Assimp Exporter"
+                << "</authoring_tool>" << endstr;
+    } else {
+        mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
+    }
+
+    if (meta) {
+        if (meta->Get("Comments", value)) {
+            mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
+        }
+        if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
+            mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
+        }
+        if (meta->Get("SourceData", value)) {
+            mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</contributor>" << endstr;
+
+    if (nullptr == meta || !meta->Get("Created", value)) {
+        mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
+    } else {
+        mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
+    }
+
+    // Modified date is always the date saved
+    mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
+
+    if (meta) {
+        if (meta->Get("Keywords", value)) {
+            mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
+        }
+        if (meta->Get("Revision", value)) {
+            mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
+        }
+        if (meta->Get("Subject", value)) {
+            mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
+        }
+        if (meta->Get("Title", value)) {
+            mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
+        }
+    }
+
+    mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
+    mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
+    PopTag();
+    mOutput << startstr << "</asset>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteTextures() {
+    static const unsigned int buffer_size = 1024;
+    char str[buffer_size];
+
+    if (mScene->HasTextures()) {
+        for (unsigned int i = 0; i < mScene->mNumTextures; i++) {
+            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
+            // so we just write the textures in the current directory.
+
+            aiTexture *texture = mScene->mTextures[i];
+            if (nullptr == texture) {
+                continue;
+            }
+
+            ASSIMP_itoa10(str, buffer_size, i + 1);
+
+            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char *)texture->achFormatHint);
+
+            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
+            if (outfile == nullptr) {
+                throw DeadlyExportError("could not open output texture file: " + mPath + name);
+            }
+
+            if (texture->mHeight == 0) {
+                outfile->Write((void *)texture->pcData, texture->mWidth, 1);
+            } else {
+                Bitmap::Save(texture, outfile.get());
+            }
+
+            outfile->Flush();
+
+            textures.insert(std::make_pair(i, name));
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteCamerasLibrary() {
+    if (mScene->HasCameras()) {
+
+        mOutput << startstr << "<library_cameras>" << endstr;
+        PushTag();
+
+        for (size_t a = 0; a < mScene->mNumCameras; ++a)
+            WriteCamera(a);
+
+        PopTag();
+        mOutput << startstr << "</library_cameras>" << endstr;
+    }
+}
+
+void ColladaExporter::WriteCamera(size_t pIndex) {
+
+    const aiCamera *cam = mScene->mCameras[pIndex];
+    const std::string cameraId = GetObjectUniqueId(AiObjectType::Camera, pIndex);
+    const std::string cameraName = GetObjectName(AiObjectType::Camera, pIndex);
+
+    mOutput << startstr << "<camera id=\"" << cameraId << "\" name=\"" << cameraName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<optics>" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    //assimp doesn't support the import of orthographic cameras! se we write
+    //always perspective
+    mOutput << startstr << "<perspective>" << endstr;
+    PushTag();
+    mOutput << startstr << "<xfov sid=\"xfov\">" << AI_RAD_TO_DEG(cam->mHorizontalFOV)
+            << "</xfov>" << endstr;
+    mOutput << startstr << "<aspect_ratio>"
+            << cam->mAspect
+            << "</aspect_ratio>" << endstr;
+    mOutput << startstr << "<znear sid=\"znear\">"
+            << cam->mClipPlaneNear
+            << "</znear>" << endstr;
+    mOutput << startstr << "<zfar sid=\"zfar\">"
+            << cam->mClipPlaneFar
+            << "</zfar>" << endstr;
+    PopTag();
+    mOutput << startstr << "</perspective>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</optics>" << endstr;
+    PopTag();
+    mOutput << startstr << "</camera>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteLightsLibrary() {
+    if (mScene->HasLights()) {
+
+        mOutput << startstr << "<library_lights>" << endstr;
+        PushTag();
+
+        for (size_t a = 0; a < mScene->mNumLights; ++a)
+            WriteLight(a);
+
+        PopTag();
+        mOutput << startstr << "</library_lights>" << endstr;
+    }
+}
+
+void ColladaExporter::WriteLight(size_t pIndex) {
+
+    const aiLight *light = mScene->mLights[pIndex];
+    const std::string lightId = GetObjectUniqueId(AiObjectType::Light, pIndex);
+    const std::string lightName = GetObjectName(AiObjectType::Light, pIndex);
+
+    mOutput << startstr << "<light id=\"" << lightId << "\" name=\""
+            << lightName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    switch (light->mType) {
+    case aiLightSource_AMBIENT:
+        WriteAmbienttLight(light);
+        break;
+    case aiLightSource_DIRECTIONAL:
+        WriteDirectionalLight(light);
+        break;
+    case aiLightSource_POINT:
+        WritePointLight(light);
+        break;
+    case aiLightSource_SPOT:
+        WriteSpotLight(light);
+        break;
+    case aiLightSource_AREA:
+    case aiLightSource_UNDEFINED:
+    case _aiLightSource_Force32Bit:
+        break;
+    }
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</light>" << endstr;
+}
+
+void ColladaExporter::WritePointLight(const aiLight *const light) {
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<point>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+            << light->mAttenuationConstant
+            << "</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+            << light->mAttenuationLinear
+            << "</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+            << light->mAttenuationQuadratic
+            << "</quadratic_attenuation>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</point>" << endstr;
+}
+
+void ColladaExporter::WriteDirectionalLight(const aiLight *const light) {
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<directional>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</directional>" << endstr;
+}
+
+void ColladaExporter::WriteSpotLight(const aiLight *const light) {
+
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<spot>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+            << light->mAttenuationConstant
+            << "</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+            << light->mAttenuationLinear
+            << "</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+            << light->mAttenuationQuadratic
+            << "</quadratic_attenuation>" << endstr;
+    /*
+    out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
+                            srcLight->mFalloffAngle);
+    */
+
+    const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
+    mOutput << startstr << "<falloff_angle sid=\"fall_off_angle\">"
+            << fallOffAngle
+            << "</falloff_angle>" << endstr;
+    double temp = light->mAngleOuterCone - light->mAngleInnerCone;
+
+    temp = std::cos(temp);
+    temp = std::log(temp) / std::log(0.1);
+    temp = 1 / temp;
+    mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
+            << temp
+            << "</falloff_exponent>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</spot>" << endstr;
+}
+
+void ColladaExporter::WriteAmbienttLight(const aiLight *const light) {
+
+    const aiColor3D &color = light->mColorAmbient;
+    mOutput << startstr << "<ambient>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</ambient>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single surface entry from the given material keys
+bool ColladaExporter::ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex) {
+    if (pSrcMat.GetTextureCount(pTexture) > 0) {
+        aiString texfile;
+        unsigned int uvChannel = 0;
+        pSrcMat.GetTexture(pTexture, 0, &texfile, nullptr, &uvChannel);
+
+        std::string index_str(texfile.C_Str());
+
+        if (index_str.size() != 0 && index_str[0] == '*') {
+            unsigned int index;
+
+            index_str = index_str.substr(1, std::string::npos);
+
+            try {
+                index = (unsigned int)strtoul10_64<DeadlyExportError>(index_str.c_str());
+            } catch (std::exception &error) {
+                throw DeadlyExportError(error.what());
+            }
+
+            std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
+
+            if (name != textures.end()) {
+                poSurface.texture = name->second;
+            } else {
+                throw DeadlyExportError("could not find embedded texture at index " + index_str);
+            }
+        } else {
+            poSurface.texture = texfile.C_Str();
+        }
+
+        poSurface.channel = uvChannel;
+        poSurface.exist = true;
+    } else {
+        if (pKey)
+            poSurface.exist = pSrcMat.Get(pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
+    }
+    return poSurface.exist;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reimplementation of isalnum(,C locale), because AppVeyor does not see standard version.
+static bool isalnum_C(char c) {
+    return (nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", c));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes an image entry for the given surface
+void ColladaExporter::WriteImageEntry(const Surface &pSurface, const std::string &imageId) {
+    if (!pSurface.texture.empty()) {
+        mOutput << startstr << "<image id=\"" << imageId << "\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<init_from>";
+
+        // URL encode image file name first, then XML encode on top
+        std::stringstream imageUrlEncoded;
+        for (std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it) {
+            if (isalnum_C((unsigned char)*it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\')
+                imageUrlEncoded << *it;
+            else
+                imageUrlEncoded << '%' << std::hex << size_t((unsigned char)*it) << std::dec;
+        }
+        mOutput << XMLEscape(imageUrlEncoded.str());
+        mOutput << "</init_from>" << endstr;
+        PopTag();
+        mOutput << startstr << "</image>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a color-or-texture entry into an effect definition
+void ColladaExporter::WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId) {
+    if (pSurface.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        if (pSurface.texture.empty()) {
+            mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
+        } else {
+            mOutput << startstr << "<texture texture=\"" << imageId << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the two parameters necessary for referencing a texture in an effect entry
+void ColladaExporter::WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId) {
+    // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
+    if (!pSurface.texture.empty()) {
+        mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-surface\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<surface type=\"2D\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<init_from>" << materialId << "-" << pTypeName << "-image</init_from>" << endstr;
+        PopTag();
+        mOutput << startstr << "</surface>" << endstr;
+        PopTag();
+        mOutput << startstr << "</newparam>" << endstr;
+
+        mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-sampler\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<sampler2D>" << endstr;
+        PushTag();
+        mOutput << startstr << "<source>" << materialId << "-" << pTypeName << "-surface</source>" << endstr;
+        PopTag();
+        mOutput << startstr << "</sampler2D>" << endstr;
+        PopTag();
+        mOutput << startstr << "</newparam>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a scalar property
+void ColladaExporter::WriteFloatEntry(const Property &pProperty, const std::string &pTypeName) {
+    if (pProperty.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the material setup
+void ColladaExporter::WriteMaterials() {
+    std::vector<Material> materials;
+    materials.resize(mScene->mNumMaterials);
+
+    /// collect all materials from the scene
+    size_t numTextures = 0;
+    for (size_t a = 0; a < mScene->mNumMaterials; ++a) {
+        Material &material = materials[a];
+        material.id = GetObjectUniqueId(AiObjectType::Material, a);
+        material.name = GetObjectName(AiObjectType::Material, a);
+
+        const aiMaterial &mat = *(mScene->mMaterials[a]);
+        aiShadingMode shading = aiShadingMode_Flat;
+        material.shading_model = "phong";
+        if (mat.Get(AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) {
+            if (shading == aiShadingMode_Phong) {
+                material.shading_model = "phong";
+            } else if (shading == aiShadingMode_Blinn) {
+                material.shading_model = "blinn";
+            } else if (shading == aiShadingMode_NoShading) {
+                material.shading_model = "constant";
+            } else if (shading == aiShadingMode_Gouraud) {
+                material.shading_model = "lambert";
+            }
+        }
+
+        if (ReadMaterialSurface(material.ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT))
+            ++numTextures;
+        if (ReadMaterialSurface(material.diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE))
+            ++numTextures;
+        if (ReadMaterialSurface(material.specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR))
+            ++numTextures;
+        if (ReadMaterialSurface(material.emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE))
+            ++numTextures;
+        if (ReadMaterialSurface(material.reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE))
+            ++numTextures;
+        if (ReadMaterialSurface(material.transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT))
+            ++numTextures;
+        if (ReadMaterialSurface(material.normal, mat, aiTextureType_NORMALS, nullptr, 0, 0))
+            ++numTextures;
+
+        material.shininess.exist = mat.Get(AI_MATKEY_SHININESS, material.shininess.value) == aiReturn_SUCCESS;
+        material.transparency.exist = mat.Get(AI_MATKEY_OPACITY, material.transparency.value) == aiReturn_SUCCESS;
+        material.index_refraction.exist = mat.Get(AI_MATKEY_REFRACTI, material.index_refraction.value) == aiReturn_SUCCESS;
+    }
+
+    // output textures if present
+    if (numTextures > 0) {
+        mOutput << startstr << "<library_images>" << endstr;
+        PushTag();
+        for (const Material &mat : materials) {
+            WriteImageEntry(mat.ambient, mat.id + "-ambient-image");
+            WriteImageEntry(mat.diffuse, mat.id + "-diffuse-image");
+            WriteImageEntry(mat.specular, mat.id + "-specular-image");
+            WriteImageEntry(mat.emissive, mat.id + "-emission-image");
+            WriteImageEntry(mat.reflective, mat.id + "-reflective-image");
+            WriteImageEntry(mat.transparent, mat.id + "-transparent-image");
+            WriteImageEntry(mat.normal, mat.id + "-normal-image");
+        }
+        PopTag();
+        mOutput << startstr << "</library_images>" << endstr;
+    }
+
+    // output effects - those are the actual carriers of information
+    if (!materials.empty()) {
+        mOutput << startstr << "<library_effects>" << endstr;
+        PushTag();
+        for (const Material &mat : materials) {
+            // this is so ridiculous it must be right
+            mOutput << startstr << "<effect id=\"" << mat.id << "-fx\" name=\"" << mat.name << "\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<profile_COMMON>" << endstr;
+            PushTag();
+
+            // write sampler- and surface params for the texture entries
+            WriteTextureParamEntry(mat.emissive, "emission", mat.id);
+            WriteTextureParamEntry(mat.ambient, "ambient", mat.id);
+            WriteTextureParamEntry(mat.diffuse, "diffuse", mat.id);
+            WriteTextureParamEntry(mat.specular, "specular", mat.id);
+            WriteTextureParamEntry(mat.reflective, "reflective", mat.id);
+            WriteTextureParamEntry(mat.transparent, "transparent", mat.id);
+            WriteTextureParamEntry(mat.normal, "normal", mat.id);
+
+            mOutput << startstr << "<technique sid=\"standard\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<" << mat.shading_model << ">" << endstr;
+            PushTag();
+
+            WriteTextureColorEntry(mat.emissive, "emission", mat.id + "-emission-sampler");
+            WriteTextureColorEntry(mat.ambient, "ambient", mat.id + "-ambient-sampler");
+            WriteTextureColorEntry(mat.diffuse, "diffuse", mat.id + "-diffuse-sampler");
+            WriteTextureColorEntry(mat.specular, "specular", mat.id + "-specular-sampler");
+            WriteFloatEntry(mat.shininess, "shininess");
+            WriteTextureColorEntry(mat.reflective, "reflective", mat.id + "-reflective-sampler");
+            WriteTextureColorEntry(mat.transparent, "transparent", mat.id + "-transparent-sampler");
+            WriteFloatEntry(mat.transparency, "transparency");
+            WriteFloatEntry(mat.index_refraction, "index_of_refraction");
+
+            if (!mat.normal.texture.empty()) {
+                WriteTextureColorEntry(mat.normal, "bump", mat.id + "-normal-sampler");
+            }
+
+            PopTag();
+            mOutput << startstr << "</" << mat.shading_model << ">" << endstr;
+            PopTag();
+            mOutput << startstr << "</technique>" << endstr;
+            PopTag();
+            mOutput << startstr << "</profile_COMMON>" << endstr;
+            PopTag();
+            mOutput << startstr << "</effect>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</library_effects>" << endstr;
+
+        // write materials - they're just effect references
+        mOutput << startstr << "<library_materials>" << endstr;
+        PushTag();
+        for (std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+            const Material &mat = *it;
+            mOutput << startstr << "<material id=\"" << mat.id << "\" name=\"" << mat.name << "\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<instance_effect url=\"#" << mat.id << "-fx\"/>" << endstr;
+            PopTag();
+            mOutput << startstr << "</material>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</library_materials>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the controller library
+void ColladaExporter::WriteControllerLibrary() {
+    mOutput << startstr << "<library_controllers>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a) {
+        WriteController(a);
+    }
+
+    PopTag();
+    mOutput << startstr << "</library_controllers>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a skin controller of the given mesh
+void ColladaExporter::WriteController(size_t pIndex) {
+    const aiMesh *mesh = mScene->mMeshes[pIndex];
+    // Is there a skin controller?
+    if (mesh->mNumBones == 0 || mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+        return;
+
+    const std::string idstr = GetObjectUniqueId(AiObjectType::Mesh, pIndex);
+    const std::string namestr = GetObjectName(AiObjectType::Mesh, pIndex);
+
+    mOutput << startstr << "<controller id=\"" << idstr << "-skin\" ";
+    mOutput << "name=\"skinCluster" << pIndex << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<skin source=\"#" << idstr << "\">" << endstr;
+    PushTag();
+
+    // bind pose matrix
+    mOutput << startstr << "<bind_shape_matrix>" << endstr;
+    PushTag();
+
+    // I think it is identity in general cases.
+    aiMatrix4x4 mat;
+    mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr;
+    mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr;
+    mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr;
+    mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr;
+
+    PopTag();
+    mOutput << startstr << "</bind_shape_matrix>" << endstr;
+
+    mOutput << startstr << "<source id=\"" << idstr << "-skin-joints\" name=\"" << namestr << "-skin-joints\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<Name_array id=\"" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
+
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        mOutput << GetBoneUniqueId(mesh->mBones[i]) << ' ';
+
+    mOutput << "</Name_array>" << endstr;
+
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<accessor source=\"#" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+
+    std::vector<ai_real> bind_poses;
+    bind_poses.reserve(mesh->mNumBones * 16);
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for (unsigned int j = 0; j < 4; ++j)
+            bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
+
+    WriteFloatArray(idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real *)bind_poses.data(), bind_poses.size() / 16);
+
+    bind_poses.clear();
+
+    std::vector<ai_real> skin_weights;
+    skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
+
+    WriteFloatArray(idstr + "-skin-weights", FloatType_Weight, (const ai_real *)skin_weights.data(), skin_weights.size());
+
+    skin_weights.clear();
+
+    mOutput << startstr << "<joints>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstr << "-skin-joints\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstr << "-skin-bind_poses\"></input>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</joints>" << endstr;
+
+    mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstr << "-skin-joints\" offset=\"0\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstr << "-skin-weights\" offset=\"1\"></input>" << endstr;
+
+    mOutput << startstr << "<vcount>";
+
+    std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
+
+    for (size_t i = 0; i < mesh->mNumVertices; ++i)
+        mOutput << num_influences[i] << " ";
+
+    mOutput << "</vcount>" << endstr;
+
+    mOutput << startstr << "<v>";
+
+    ai_uint joint_weight_indices_length = 0;
+    std::vector<ai_uint> accum_influences;
+    accum_influences.reserve(num_influences.size());
+    for (size_t i = 0; i < num_influences.size(); ++i) {
+        accum_influences.push_back(joint_weight_indices_length);
+        joint_weight_indices_length += num_influences[i];
+    }
+
+    ai_uint weight_index = 0;
+    std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for (unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j) {
+            unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
+            for (ai_uint k = 0; k < num_influences[vId]; ++k) {
+                if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1) {
+                    joint_weight_indices[2 * (accum_influences[vId] + k)] = i;
+                    joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index;
+                    break;
+                }
+            }
+            ++weight_index;
+        }
+
+    for (size_t i = 0; i < joint_weight_indices.size(); ++i)
+        mOutput << joint_weight_indices[i] << " ";
+
+    num_influences.clear();
+    accum_influences.clear();
+    joint_weight_indices.clear();
+
+    mOutput << "</v>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</vertex_weights>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</skin>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</controller>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the geometry library
+void ColladaExporter::WriteGeometryLibrary() {
+    mOutput << startstr << "<library_geometries>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a)
+        WriteGeometry(a);
+
+    PopTag();
+    mOutput << startstr << "</library_geometries>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the given mesh
+void ColladaExporter::WriteGeometry(size_t pIndex) {
+    const aiMesh *mesh = mScene->mMeshes[pIndex];
+    const std::string geometryId = GetObjectUniqueId(AiObjectType::Mesh, pIndex);
+    const std::string geometryName = GetObjectName(AiObjectType::Mesh, pIndex);
+
+    if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+        return;
+
+    // opening tag
+    mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<mesh>" << endstr;
+    PushTag();
+
+    // Positions
+    WriteFloatArray(geometryId + "-positions", FloatType_Vector, (ai_real *)mesh->mVertices, mesh->mNumVertices);
+    // Normals, if any
+    if (mesh->HasNormals())
+        WriteFloatArray(geometryId + "-normals", FloatType_Vector, (ai_real *)mesh->mNormals, mesh->mNumVertices);
+
+    // texture coords
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (mesh->HasTextureCoords(static_cast<unsigned int>(a))) {
+            WriteFloatArray(geometryId + "-tex" + ai_to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
+                    (ai_real *)mesh->mTextureCoords[a], mesh->mNumVertices);
+        }
+    }
+
+    // vertex colors
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+            WriteFloatArray(geometryId + "-color" + ai_to_string(a), FloatType_Color, (ai_real *)mesh->mColors[a], mesh->mNumVertices);
+    }
+
+    // assemble vertex structure
+    // Only write input for POSITION since we will write other as shared inputs in polygon definition
+    mOutput << startstr << "<vertices id=\"" << geometryId << "-vertices"
+            << "\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</vertices>" << endstr;
+
+    // count the number of lines, triangles and polygon meshes
+    int countLines = 0;
+    int countPoly = 0;
+    for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+        if (mesh->mFaces[a].mNumIndices == 2)
+            countLines++;
+        else if (mesh->mFaces[a].mNumIndices >= 3)
+            countPoly++;
+    }
+
+    // lines
+    if (countLines) {
+        mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if (mesh->HasNormals())
+            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+            if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+
+        mOutput << startstr << "<p>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            const aiFace &face = mesh->mFaces[a];
+            if (face.mNumIndices != 2) continue;
+            for (size_t b = 0; b < face.mNumIndices; ++b)
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</lines>" << endstr;
+    }
+
+    // triangle - don't use it, because compatibility problems
+
+    // polygons
+    if (countPoly) {
+        mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if (mesh->HasNormals())
+            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+            if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+
+        mOutput << startstr << "<vcount>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            if (mesh->mFaces[a].mNumIndices < 3) continue;
+            mOutput << mesh->mFaces[a].mNumIndices << " ";
+        }
+        mOutput << "</vcount>" << endstr;
+
+        mOutput << startstr << "<p>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            const aiFace &face = mesh->mFaces[a];
+            if (face.mNumIndices < 3) continue;
+            for (size_t b = 0; b < face.mNumIndices; ++b)
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</polylist>" << endstr;
+    }
+
+    // closing tags
+    PopTag();
+    mOutput << startstr << "</mesh>" << endstr;
+    PopTag();
+    mOutput << startstr << "</geometry>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a float array of the given type
+void ColladaExporter::WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount) {
+    size_t floatsPerElement = 0;
+    switch (pType) {
+    case FloatType_Vector: floatsPerElement = 3; break;
+    case FloatType_TexCoord2: floatsPerElement = 2; break;
+    case FloatType_TexCoord3: floatsPerElement = 3; break;
+    case FloatType_Color: floatsPerElement = 3; break;
+    case FloatType_Mat4x4: floatsPerElement = 16; break;
+    case FloatType_Weight: floatsPerElement = 1; break;
+    case FloatType_Time: floatsPerElement = 1; break;
+    default:
+        return;
+    }
+
+    std::string arrayId = XMLIDEncode(pIdString) + "-array";
+
+    mOutput << startstr << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
+    PushTag();
+
+    // source array
+    mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
+    PushTag();
+
+    if (pType == FloatType_TexCoord2) {
+        for (size_t a = 0; a < pElementCount; ++a) {
+            mOutput << pData[a * 3 + 0] << " ";
+            mOutput << pData[a * 3 + 1] << " ";
+        }
+    } else if (pType == FloatType_Color) {
+        for (size_t a = 0; a < pElementCount; ++a) {
+            mOutput << pData[a * 4 + 0] << " ";
+            mOutput << pData[a * 4 + 1] << " ";
+            mOutput << pData[a * 4 + 2] << " ";
+        }
+    } else {
+        for (size_t a = 0; a < pElementCount * floatsPerElement; ++a)
+            mOutput << pData[a] << " ";
+    }
+    mOutput << "</float_array>" << endstr;
+    PopTag();
+
+    // the usual Collada fun. Let's bloat it even more!
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
+    PushTag();
+
+    switch (pType) {
+    case FloatType_Vector:
+        mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_TexCoord2:
+        mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_TexCoord3:
+        mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_Color:
+        mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_Mat4x4:
+        mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
+        break;
+
+    case FloatType_Weight:
+        mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
+        break;
+
+    // customized, add animation related
+    case FloatType_Time:
+        mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
+        break;
+    }
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the scene library
+void ColladaExporter::WriteSceneLibrary() {
+    // Determine if we are using the aiScene root or our own
+    std::string sceneName("Scene");
+    if (mAdd_root_node) {
+        mSceneId = MakeUniqueId(mUniqueIds, sceneName, std::string());
+        mUniqueIds.insert(mSceneId);
+    } else {
+        mSceneId = GetNodeUniqueId(mScene->mRootNode);
+        sceneName = GetNodeName(mScene->mRootNode);
+    }
+
+    mOutput << startstr << "<library_visual_scenes>" << endstr;
+    PushTag();
+    mOutput << startstr << "<visual_scene id=\"" + mSceneId + "\" name=\"" + sceneName + "\">" << endstr;
+    PushTag();
+
+    if (mAdd_root_node) {
+        // Export the root node
+        WriteNode(mScene->mRootNode);
+    } else {
+        // Have already exported the root node
+        for (size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a)
+            WriteNode(mScene->mRootNode->mChildren[a]);
+    }
+
+    PopTag();
+    mOutput << startstr << "</visual_scene>" << endstr;
+    PopTag();
+    mOutput << startstr << "</library_visual_scenes>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
+    const aiAnimation *anim = mScene->mAnimations[pIndex];
+
+    if (anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels == 0)
+        return;
+
+    const std::string animationNameEscaped = GetObjectName(AiObjectType::Animation, pIndex);
+    const std::string idstrEscaped = GetObjectUniqueId(AiObjectType::Animation, pIndex);
+
+    mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animationNameEscaped + "\">" << endstr;
+    PushTag();
+
+    std::string cur_node_idstr;
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        // sanity check
+        if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) {
+            continue;
+        }
+
+        {
+            cur_node_idstr.clear();
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-input");
+
+            std::vector<ai_real> frames;
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                frames.push_back(static_cast<ai_real>(nodeAnim->mPositionKeys[i].mTime));
+            }
+
+            WriteFloatArray(cur_node_idstr, FloatType_Time, (const ai_real *)frames.data(), frames.size());
+            frames.clear();
+        }
+
+        {
+            cur_node_idstr.clear();
+
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-output");
+
+            std::vector<ai_real> keyframes;
+            keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
+                aiMatrix4x4 ScalingM; // identity
+                ScalingM[0][0] = Scaling.x;
+                ScalingM[1][1] = Scaling.y;
+                ScalingM[2][2] = Scaling.z;
+
+                aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
+                aiMatrix4x4 s = aiMatrix4x4(RotationQ.GetMatrix());
+                aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
+
+                aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
+                aiMatrix4x4 TranslationM; // identity
+                TranslationM[0][3] = Translation.x;
+                TranslationM[1][3] = Translation.y;
+                TranslationM[2][3] = Translation.z;
+
+                // Combine the above transformations
+                aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
+
+                for (unsigned int j = 0; j < 4; ++j) {
+                    keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
+                }
+            }
+
+            WriteFloatArray(cur_node_idstr, FloatType_Mat4x4, (const ai_real *)keyframes.data(), keyframes.size() / 16);
+        }
+
+        {
+            std::vector<std::string> names;
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                if (nodeAnim->mPreState == aiAnimBehaviour_DEFAULT || nodeAnim->mPreState == aiAnimBehaviour_LINEAR || nodeAnim->mPreState == aiAnimBehaviour_REPEAT) {
+                    names.push_back("LINEAR");
+                } else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
+                    names.push_back("STEP");
+                }
+            }
+
+            const std::string cur_node_idstr2 = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
+            std::string arrayId = XMLIDEncode(cur_node_idstr2) + "-array";
+
+            mOutput << startstr << "<source id=\"" << XMLIDEncode(cur_node_idstr2) << "\">" << endstr;
+            PushTag();
+
+            // source array
+            mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
+            for (size_t aa = 0; aa < names.size(); ++aa) {
+                mOutput << names[aa] << " ";
+            }
+            mOutput << "</Name_array>" << endstr;
+
+            mOutput << startstr << "<technique_common>" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</accessor>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</technique_common>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</source>" << endstr;
+        }
+    }
+
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        {
+            // samplers
+            const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
+            mOutput << startstr << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-input")) << "\"/>" << endstr;
+            mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-output")) << "\"/>" << endstr;
+            mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-interpolation")) << "\"/>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</sampler>" << endstr;
+        }
+    }
+
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        {
+            // channels
+            mOutput << startstr << "<channel source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-sampler")) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</animation>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationsLibrary() {
+    if (mScene->mNumAnimations > 0) {
+        mOutput << startstr << "<library_animations>" << endstr;
+        PushTag();
+
+        // start recursive write at the root node
+        for (size_t a = 0; a < mScene->mNumAnimations; ++a)
+            WriteAnimationLibrary(a);
+
+        PopTag();
+        mOutput << startstr << "</library_animations>" << endstr;
+    }
+}
+// ------------------------------------------------------------------------------------------------
+// Helper to find a bone by name in the scene
+aiBone *findBone(const aiScene *scene, const aiString &name) {
+    for (size_t m = 0; m < scene->mNumMeshes; m++) {
+        aiMesh *mesh = scene->mMeshes[m];
+        for (size_t b = 0; b < mesh->mNumBones; b++) {
+            aiBone *bone = mesh->mBones[b];
+            if (name == bone->mName) {
+                return bone;
+            }
+        }
+    }
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Helper to find the node associated with a bone in the scene
+const aiNode *findBoneNode(const aiNode *aNode, const aiBone *bone) {
+    if (aNode && bone && aNode->mName == bone->mName) {
+        return aNode;
+    }
+
+    if (aNode && bone) {
+        for (unsigned int i = 0; i < aNode->mNumChildren; ++i) {
+            aiNode *aChild = aNode->mChildren[i];
+            const aiNode *foundFromChild = nullptr;
+            if (aChild) {
+                foundFromChild = findBoneNode(aChild, bone);
+                if (foundFromChild) {
+                    return foundFromChild;
+                }
+            }
+        }
+    }
+
+    return nullptr;
+}
+
+const aiNode *findSkeletonRootNode(const aiScene *scene, const aiMesh *mesh) {
+    std::set<const aiNode *> topParentBoneNodes;
+    if (mesh && mesh->mNumBones > 0) {
+        for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
+            aiBone *bone = mesh->mBones[i];
+
+            const aiNode *node = findBoneNode(scene->mRootNode, bone);
+            if (node) {
+                while (node->mParent && findBone(scene, node->mParent->mName) != nullptr) {
+                    node = node->mParent;
+                }
+                topParentBoneNodes.insert(node);
+            }
+        }
+    }
+
+    if (!topParentBoneNodes.empty()) {
+        const aiNode *parentBoneNode = *topParentBoneNodes.begin();
+        if (topParentBoneNodes.size() == 1) {
+            return parentBoneNode;
+        } else {
+            for (auto it : topParentBoneNodes) {
+                if (it->mParent) return it->mParent;
+            }
+            return parentBoneNode;
+        }
+    }
+
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Recursively writes the given node
+void ColladaExporter::WriteNode(const aiNode *pNode) {
+    // If the node is associated with a bone, it is a joint node (JOINT)
+    // otherwise it is a normal node (NODE)
+    // Assimp-specific: nodes with no name cannot be associated with bones
+    const char *node_type;
+    bool is_joint, is_skeleton_root = false;
+    if (pNode->mName.length == 0 || nullptr == findBone(mScene, pNode->mName)) {
+        node_type = "NODE";
+        is_joint = false;
+    } else {
+        node_type = "JOINT";
+        is_joint = true;
+        if (!pNode->mParent || nullptr == findBone(mScene, pNode->mParent->mName)) {
+            is_skeleton_root = true;
+        }
+    }
+
+    const std::string node_id = GetNodeUniqueId(pNode);
+    const std::string node_name = GetNodeName(pNode);
+    mOutput << startstr << "<node ";
+    if (is_skeleton_root) {
+        mFoundSkeletonRootNodeID = node_id; // For now, only support one skeleton in a scene.
+    }
+    mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id + "\" " : "");
+    mOutput << "name=\"" << node_name
+            << "\" type=\"" << node_type
+            << "\">" << endstr;
+    PushTag();
+
+    // write transformation - we can directly put the matrix there
+    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
+    aiMatrix4x4 mat = pNode->mTransformation;
+
+    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
+    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
+    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
+    // coordinate system must be changed to matche the Collada specification.
+    for (size_t i = 0; i < mScene->mNumCameras; i++) {
+        if (mScene->mCameras[i]->mName == pNode->mName) {
+            aiMatrix4x4 sourceView;
+            mScene->mCameras[i]->GetCameraMatrix(sourceView);
+
+            aiMatrix4x4 colladaView;
+            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
+            mat *= (sourceView * colladaView);
+            break;
+        }
+    }
+
+    // customized, sid should be 'matrix' to match with loader code.
+    //mOutput << startstr << "<matrix sid=\"transform\">";
+    mOutput << startstr << "<matrix sid=\"matrix\">";
+
+    mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
+    mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
+    mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
+    mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
+    mOutput << "</matrix>" << endstr;
+
+    if (pNode->mNumMeshes == 0) {
+        //check if it is a camera node
+        for (size_t i = 0; i < mScene->mNumCameras; i++) {
+            if (mScene->mCameras[i]->mName == pNode->mName) {
+                mOutput << startstr << "<instance_camera url=\"#" << GetObjectUniqueId(AiObjectType::Camera, i) << "\"/>" << endstr;
+                break;
+            }
+        }
+        //check if it is a light node
+        for (size_t i = 0; i < mScene->mNumLights; i++) {
+            if (mScene->mLights[i]->mName == pNode->mName) {
+                mOutput << startstr << "<instance_light url=\"#" << GetObjectUniqueId(AiObjectType::Light, i) << "\"/>" << endstr;
+                break;
+            }
+        }
+
+    } else
+        // instance every geometry
+        for (size_t a = 0; a < pNode->mNumMeshes; ++a) {
+            const aiMesh *mesh = mScene->mMeshes[pNode->mMeshes[a]];
+            // do not instantiate mesh if empty. I wonder how this could happen
+            if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+                continue;
+
+            const std::string meshId = GetObjectUniqueId(AiObjectType::Mesh, pNode->mMeshes[a]);
+
+            if (mesh->mNumBones == 0) {
+                mOutput << startstr << "<instance_geometry url=\"#" << meshId << "\">" << endstr;
+                PushTag();
+            } else {
+                mOutput << startstr
+                        << "<instance_controller url=\"#" << meshId << "-skin\">"
+                        << endstr;
+                PushTag();
+
+                // note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
+                // use the first bone to find skeleton root
+                const aiNode *skeletonRootBoneNode = findSkeletonRootNode(mScene, mesh);
+                if (skeletonRootBoneNode) {
+                    mFoundSkeletonRootNodeID = GetNodeUniqueId(skeletonRootBoneNode);
+                }
+                mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
+            }
+            mOutput << startstr << "<bind_material>" << endstr;
+            PushTag();
+            mOutput << startstr << "<technique_common>" << endstr;
+            PushTag();
+            mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << GetObjectUniqueId(AiObjectType::Material, mesh->mMaterialIndex) << "\">" << endstr;
+            PushTag();
+            for (size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa) {
+                if (mesh->HasTextureCoords(static_cast<unsigned int>(aa)))
+                    // semantic       as in <texture texcoord=...>
+                    // input_semantic as in <input semantic=...>
+                    // input_set      as in <input set=...>
+                    mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << aa << "\" input_semantic=\"TEXCOORD\" input_set=\"" << aa << "\"/>" << endstr;
+            }
+            PopTag();
+            mOutput << startstr << "</instance_material>" << endstr;
+            PopTag();
+            mOutput << startstr << "</technique_common>" << endstr;
+            PopTag();
+            mOutput << startstr << "</bind_material>" << endstr;
+
+            PopTag();
+            if (mesh->mNumBones == 0)
+                mOutput << startstr << "</instance_geometry>" << endstr;
+            else
+                mOutput << startstr << "</instance_controller>" << endstr;
+        }
+
+    // recurse into subnodes
+    for (size_t a = 0; a < pNode->mNumChildren; ++a)
+        WriteNode(pNode->mChildren[a]);
+
+    PopTag();
+    mOutput << startstr << "</node>" << endstr;
+}
+
+void ColladaExporter::CreateNodeIds(const aiNode *node) {
+    GetNodeUniqueId(node);
+    for (size_t a = 0; a < node->mNumChildren; ++a)
+        CreateNodeIds(node->mChildren[a]);
+}
+
+std::string ColladaExporter::GetNodeUniqueId(const aiNode *node) {
+    // Use the pointer as the key. This is safe because the scene is immutable.
+    auto idIt = mNodeIdMap.find(node);
+    if (idIt != mNodeIdMap.cend())
+        return idIt->second;
+
+    // Prefer the requested Collada Id if extant
+    std::string idStr;
+    aiString origId;
+    if (node->mMetaData && node->mMetaData->Get(AI_METADATA_COLLADA_ID, origId)) {
+        idStr = origId.C_Str();
+    } else {
+        idStr = node->mName.C_Str();
+    }
+    // Make sure the requested id is valid
+    if (idStr.empty())
+        idStr = "node";
+    else
+        idStr = XMLIDEncode(idStr);
+
+    // Ensure it's unique
+    idStr = MakeUniqueId(mUniqueIds, idStr, std::string());
+    mUniqueIds.insert(idStr);
+    mNodeIdMap.insert(std::make_pair(node, idStr));
+    return idStr;
+}
+
+std::string ColladaExporter::GetNodeName(const aiNode *node) {
+
+    return XMLEscape(node->mName.C_Str());
+}
+
+std::string ColladaExporter::GetBoneUniqueId(const aiBone *bone) {
+    // Find the Node that is this Bone
+    const aiNode *boneNode = findBoneNode(mScene->mRootNode, bone);
+    if (boneNode == nullptr)
+        return std::string();
+
+    return GetNodeUniqueId(boneNode);
+}
+
+std::string ColladaExporter::GetObjectUniqueId(AiObjectType type, size_t pIndex) {
+    auto idIt = GetObjectIdMap(type).find(pIndex);
+    if (idIt != GetObjectIdMap(type).cend())
+        return idIt->second;
+
+    // Not seen this object before, create and add
+    NameIdPair result = AddObjectIndexToMaps(type, pIndex);
+    return result.second;
+}
+
+std::string ColladaExporter::GetObjectName(AiObjectType type, size_t pIndex) {
+    auto objectName = GetObjectNameMap(type).find(pIndex);
+    if (objectName != GetObjectNameMap(type).cend())
+        return objectName->second;
+
+    // Not seen this object before, create and add
+    NameIdPair result = AddObjectIndexToMaps(type, pIndex);
+    return result.first;
+}
+
+// Determine unique id and add the name and id to the maps
+// @param type object type
+// @param index object index
+// @param name in/out. Caller to set the original name if known.
+// @param idStr in/out. Caller to set the preferred id if known.
+ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType type, size_t index) {
+
+    std::string name;
+    std::string idStr;
+    std::string idPostfix;
+
+    // Get the name and id postfix
+    switch (type) {
+    case AiObjectType::Mesh: name = mScene->mMeshes[index]->mName.C_Str(); break;
+    case AiObjectType::Material: name = mScene->mMaterials[index]->GetName().C_Str(); break;
+    case AiObjectType::Animation: name = mScene->mAnimations[index]->mName.C_Str(); break;
+    case AiObjectType::Light:
+        name = mScene->mLights[index]->mName.C_Str();
+        idPostfix = "-light";
+        break;
+    case AiObjectType::Camera:
+        name = mScene->mCameras[index]->mName.C_Str();
+        idPostfix = "-camera";
+        break;
+    case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type");
+    }
+
+    if (name.empty()) {
+        // Default ids if empty name
+        switch (type) {
+        case AiObjectType::Mesh: idStr = std::string("mesh_"); break;
+        case AiObjectType::Material: idStr = std::string("material_"); break; // This one should never happen
+        case AiObjectType::Animation: idStr = std::string("animation_"); break;
+        case AiObjectType::Light: idStr = std::string("light_"); break;
+        case AiObjectType::Camera: idStr = std::string("camera_"); break;
+        case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type");
+        }
+        idStr.append(ai_to_string(index));
+    } else {
+        idStr = XMLIDEncode(name);
+    }
+
+    if (!name.empty())
+        name = XMLEscape(name);
+
+    idStr = MakeUniqueId(mUniqueIds, idStr, idPostfix);
+
+    // Add to maps
+    mUniqueIds.insert(idStr);
+    GetObjectIdMap(type).insert(std::make_pair(index, idStr));
+    GetObjectNameMap(type).insert(std::make_pair(index, name));
+
+    return std::make_pair(name, idStr);
+}
+
+} // end of namespace Assimp
+
+#endif
+#endif
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h
new file mode 100644
index 0000000..56415fb
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h
@@ -0,0 +1,257 @@
+/*
+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 ColladaExporter.h
+ * Declares the exporter class to write a scene to a Collada file
+ */
+#ifndef AI_COLLADAEXPORTER_H_INC
+#define AI_COLLADAEXPORTER_H_INC
+
+#include <assimp/ai_assert.h>
+#include <assimp/material.h>
+
+#include <array>
+#include <map>
+#include <sstream>
+#include <unordered_set>
+#include <vector>
+
+struct aiScene;
+struct aiNode;
+struct aiLight;
+struct aiBone;
+
+namespace Assimp {
+
+class IOSystem;
+
+/// Helper class to export a given scene to a Collada file. Just for my personal
+/// comfort when implementing it.
+class ColladaExporter {
+public:
+    /// Constructor for a specific scene to export
+    ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file);
+
+    /// Destructor
+    virtual ~ColladaExporter();
+
+protected:
+    /// Starts writing the contents
+    void WriteFile();
+
+    /// Writes the asset header
+    void WriteHeader();
+
+    /// Writes the embedded textures
+    void WriteTextures();
+
+    /// Writes the material setup
+    void WriteMaterials();
+
+    /// Writes the cameras library
+    void WriteCamerasLibrary();
+
+    // Write a camera entry
+    void WriteCamera(size_t pIndex);
+
+    /// Writes the cameras library
+    void WriteLightsLibrary();
+
+    // Write a camera entry
+    void WriteLight(size_t pIndex);
+    void WritePointLight(const aiLight *const light);
+    void WriteDirectionalLight(const aiLight *const light);
+    void WriteSpotLight(const aiLight *const light);
+    void WriteAmbienttLight(const aiLight *const light);
+
+    /// Writes the controller library
+    void WriteControllerLibrary();
+
+    /// Writes a skin controller of the given mesh
+    void WriteController(size_t pIndex);
+
+    /// Writes the geometry library
+    void WriteGeometryLibrary();
+
+    /// Writes the given mesh
+    void WriteGeometry(size_t pIndex);
+
+    //enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight };
+    // customized to add animation related type
+    enum FloatDataType { FloatType_Vector,
+        FloatType_TexCoord2,
+        FloatType_TexCoord3,
+        FloatType_Color,
+        FloatType_Mat4x4,
+        FloatType_Weight,
+        FloatType_Time };
+
+    /// Writes a float array of the given type
+    void WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount);
+
+    /// Writes the scene library
+    void WriteSceneLibrary();
+
+    // customized, Writes the animation library
+    void WriteAnimationsLibrary();
+    void WriteAnimationLibrary(size_t pIndex);
+    std::string mFoundSkeletonRootNodeID = "skeleton_root"; // will be replaced by found node id in the WriteNode call.
+
+    /// Recursively writes the given node
+    void WriteNode(const aiNode *pNode);
+
+    /// Enters a new xml element, which increases the indentation
+    void PushTag() { startstr.append("  "); }
+    /// Leaves an element, decreasing the indentation
+    void PopTag() {
+        ai_assert(startstr.length() > 1);
+        startstr.erase(startstr.length() - 2);
+    }
+
+    void CreateNodeIds(const aiNode *node);
+
+    /// Get or Create a unique Node ID string for the given Node
+    std::string GetNodeUniqueId(const aiNode *node);
+    std::string GetNodeName(const aiNode *node);
+
+    std::string GetBoneUniqueId(const aiBone *bone);
+
+    enum class AiObjectType {
+        Mesh,
+        Material,
+        Animation,
+        Light,
+        Camera,
+        Count,
+    };
+    /// Get or Create a unique ID string for the given scene object index
+    std::string GetObjectUniqueId(AiObjectType type, size_t pIndex);
+    /// Get or Create a name string for the given scene object index
+    std::string GetObjectName(AiObjectType type, size_t pIndex);
+
+    typedef std::map<size_t, std::string> IndexIdMap;
+    typedef std::pair<std::string, std::string> NameIdPair;
+    NameIdPair AddObjectIndexToMaps(AiObjectType type, size_t pIndex);
+
+    // Helpers
+    inline IndexIdMap &GetObjectIdMap(AiObjectType type) { return mObjectIdMap[static_cast<size_t>(type)]; }
+    inline IndexIdMap &GetObjectNameMap(AiObjectType type) { return mObjectNameMap[static_cast<size_t>(type)]; }
+
+private:
+    std::unordered_set<std::string> mUniqueIds; // Cache of used unique ids
+    std::map<const void *, std::string> mNodeIdMap; // Cache of encoded node and bone ids
+    std::array<IndexIdMap, static_cast<size_t>(AiObjectType::Count)> mObjectIdMap; // Cache of encoded unique IDs
+    std::array<IndexIdMap, static_cast<size_t>(AiObjectType::Count)> mObjectNameMap; // Cache of encoded names
+
+public:
+    /// Stringstream to write all output into
+    std::stringstream mOutput;
+
+    /// The IOSystem for output
+    IOSystem *mIOSystem;
+
+    /// Path of the directory where the scene will be exported
+    const std::string mPath;
+
+    /// Name of the file (without extension) where the scene will be exported
+    const std::string mFile;
+
+    /// The scene to be written
+    const aiScene *const mScene;
+    std::string mSceneId;
+    bool mAdd_root_node = false;
+
+    /// current line start string, contains the current indentation for simple stream insertion
+    std::string startstr;
+    /// current line end string for simple stream insertion
+    const std::string endstr;
+
+    // pair of color and texture - texture precedences color
+    struct Surface {
+        bool exist;
+        aiColor4D color;
+        std::string texture;
+        size_t channel;
+        Surface() {
+            exist = false;
+            channel = 0;
+        }
+    };
+
+    struct Property {
+        bool exist;
+        ai_real value;
+        Property() :
+                exist(false),
+                value(0.0) {}
+    };
+
+    // summarize a material in an convenient way.
+    struct Material {
+        std::string id;
+        std::string name;
+        std::string shading_model;
+        Surface ambient, diffuse, specular, emissive, reflective, transparent, normal;
+        Property shininess, transparency, index_refraction;
+
+        Material() {}
+    };
+
+    std::map<unsigned int, std::string> textures;
+
+public:
+    /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions
+    /// Reads a single surface entry from the given material keys
+    bool ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex);
+    /// Writes an image entry for the given surface
+    void WriteImageEntry(const Surface &pSurface, const std::string &imageId);
+    /// Writes the two parameters necessary for referencing a texture in an effect entry
+    void WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId);
+    /// Writes a color-or-texture entry into an effect definition
+    void WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId);
+    /// Writes a scalar property
+    void WriteFloatEntry(const Property &pProperty, const std::string &pTypeName);
+};
+
+} // namespace Assimp
+
+#endif // !! AI_COLLADAEXPORTER_H_INC
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp
new file mode 100644
index 0000000..0fb172f
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp
@@ -0,0 +1,99 @@
+/*
+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.
+
+----------------------------------------------------------------------
+*/
+/** Helper structures for the Collada loader */
+
+#include "ColladaHelper.h"
+
+#include <assimp/ParsingUtils.h>
+#include <assimp/commonMetaData.h>
+
+namespace Assimp {
+namespace Collada {
+
+const MetaKeyPairVector MakeColladaAssimpMetaKeys() {
+    MetaKeyPairVector result;
+    result.emplace_back("authoring_tool", AI_METADATA_SOURCE_GENERATOR);
+    result.emplace_back("copyright", AI_METADATA_SOURCE_COPYRIGHT);
+    return result;
+}
+
+const MetaKeyPairVector &GetColladaAssimpMetaKeys() {
+    static const MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
+    return result;
+}
+
+const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() {
+    MetaKeyPairVector result = MakeColladaAssimpMetaKeys();
+    for (auto &val : result) {
+        ToCamelCase(val.first);
+    }
+    return result;
+}
+
+const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase() {
+    static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase();
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert underscore_separated to CamelCase: "authoring_tool" becomes "AuthoringTool"
+void ToCamelCase(std::string &text) {
+    if (text.empty())
+        return;
+    // Capitalise first character
+    auto it = text.begin();
+    (*it) = ai_toupper(*it);
+    ++it;
+    for (/*started above*/; it != text.end(); /*iterated below*/) {
+        if ((*it) == '_') {
+            it = text.erase(it);
+            if (it != text.end())
+                (*it) = ai_toupper(*it);
+        } else {
+            // Make lower case
+            (*it) = ai_tolower(*it);
+            ++it;
+        }
+    }
+}
+
+} // namespace Collada
+} // namespace Assimp
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h
new file mode 100644
index 0000000..31d7b5a
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h
@@ -0,0 +1,679 @@
+/*
+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.
+
+----------------------------------------------------------------------
+*/
+
+/** Helper structures for the Collada loader */
+
+#ifndef AI_COLLADAHELPER_H_INC
+#define AI_COLLADAHELPER_H_INC
+
+#include <assimp/light.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+
+#include <cstdint>
+#include <map>
+#include <set>
+#include <vector>
+
+struct aiMaterial;
+
+namespace Assimp {
+namespace Collada {
+
+/// Collada file versions which evolved during the years ...
+enum FormatVersion {
+    FV_1_5_n,
+    FV_1_4_n,
+    FV_1_3_n
+};
+
+/// Transformation types that can be applied to a node
+enum TransformType {
+    TF_LOOKAT,
+    TF_ROTATE,
+    TF_TRANSLATE,
+    TF_SCALE,
+    TF_SKEW,
+    TF_MATRIX
+};
+
+/// Different types of input data to a vertex or face
+enum InputType {
+    IT_Invalid,
+    IT_Vertex, // special type for per-index data referring to the <vertices> element carrying the per-vertex data.
+    IT_Position,
+    IT_Normal,
+    IT_Texcoord,
+    IT_Color,
+    IT_Tangent,
+    IT_Bitangent
+};
+
+/// Supported controller types
+enum ControllerType {
+    Skin,
+    Morph
+};
+
+/// Supported morph methods
+enum MorphMethod {
+    Normalized,
+    Relative
+};
+
+/// Common metadata keys as <Collada, Assimp>
+using MetaKeyPair = std::pair<std::string, std::string>;
+using MetaKeyPairVector = std::vector<MetaKeyPair>;
+
+/// Collada as lower_case (native)
+const MetaKeyPairVector &GetColladaAssimpMetaKeys();
+
+// Collada as CamelCase (used by Assimp for consistency)
+const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase();
+
+/// Convert underscore_separated to CamelCase "authoring_tool" becomes "AuthoringTool"
+void ToCamelCase(std::string &text);
+
+/// Contains all data for one of the different transformation types
+struct Transform {
+    std::string mID; ///< SID of the transform step, by which anim channels address their target node
+    TransformType mType;
+    ai_real f[16]; ///< Interpretation of data depends on the type of the transformation
+};
+
+/// A collada camera.
+struct Camera {
+    Camera() :
+            mOrtho(false),
+            mHorFov(10e10f),
+            mVerFov(10e10f),
+            mAspect(10e10f),
+            mZNear(0.1f),
+            mZFar(1000.f) {}
+
+    /// Name of camera
+    std::string mName;
+
+    /// True if it is an orthographic camera
+    bool mOrtho;
+
+    /// Horizontal field of view in degrees
+    ai_real mHorFov;
+
+    /// Vertical field of view in degrees
+    ai_real mVerFov;
+
+    /// Screen aspect
+    ai_real mAspect;
+
+    /// Near& far z
+    ai_real mZNear, mZFar;
+};
+
+#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f
+
+/** A collada light source. */
+struct Light {
+    Light() :
+            mType(aiLightSource_UNDEFINED),
+            mAttConstant(1.f),
+            mAttLinear(0.f),
+            mAttQuadratic(0.f),
+            mFalloffAngle(180.f),
+            mFalloffExponent(0.f),
+            mPenumbraAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET),
+            mOuterAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET),
+            mIntensity(1.f) {}
+
+    /// Type of the light source aiLightSourceType + ambient
+    unsigned int mType;
+
+    /// Color of the light
+    aiColor3D mColor;
+
+    /// Light attenuation
+    ai_real mAttConstant, mAttLinear, mAttQuadratic;
+
+    /// Spot light falloff
+    ai_real mFalloffAngle;
+    ai_real mFalloffExponent;
+
+    // -----------------------------------------------------
+    // FCOLLADA extension from here
+
+    /// ... related stuff from maja and max extensions
+    ai_real mPenumbraAngle;
+    ai_real mOuterAngle;
+
+    /// Common light intensity
+    ai_real mIntensity;
+};
+
+/** Short vertex index description */
+struct InputSemanticMapEntry {
+    InputSemanticMapEntry() :
+            mSet(0),
+            mType(IT_Invalid) {}
+
+    /// Index of set, optional
+    unsigned int mSet;
+
+    /// Type of referenced vertex input
+    InputType mType;
+};
+
+/// Table to map from effect to vertex input semantics
+struct SemanticMappingTable {
+    /// Name of material
+    std::string mMatName;
+
+    /// List of semantic map commands, grouped by effect semantic name
+    using InputSemanticMap = std::map<std::string, InputSemanticMapEntry>;
+    InputSemanticMap mMap;
+
+    /// For std::find
+    bool operator==(const std::string &s) const {
+        return s == mMatName;
+    }
+};
+
+/// A reference to a mesh inside a node, including materials assigned to the various subgroups.
+/// The ID refers to either a mesh or a controller which specifies the mesh
+struct MeshInstance {
+    ///< ID of the mesh or controller to be instanced
+    std::string mMeshOrController;
+
+    ///< Map of materials by the subgroup ID they're applied to
+    std::map<std::string, SemanticMappingTable> mMaterials;
+};
+
+/// A reference to a camera inside a node
+struct CameraInstance {
+    ///< ID of the camera
+    std::string mCamera;
+};
+
+/// A reference to a light inside a node
+struct LightInstance {
+    ///< ID of the camera
+    std::string mLight;
+};
+
+/// A reference to a node inside a node
+struct NodeInstance {
+    ///< ID of the node
+    std::string mNode;
+};
+
+/// A node in a scene hierarchy
+struct Node {
+    std::string mName;
+    std::string mID;
+    std::string mSID;
+    Node *mParent;
+    std::vector<Node *> mChildren;
+
+    /// Operations in order to calculate the resulting transformation to parent.
+    std::vector<Transform> mTransforms;
+
+    /// Meshes at this node
+    std::vector<MeshInstance> mMeshes;
+
+    /// Lights at this node
+    std::vector<LightInstance> mLights;
+
+    /// Cameras at this node
+    std::vector<CameraInstance> mCameras;
+
+    /// Node instances at this node
+    std::vector<NodeInstance> mNodeInstances;
+
+    /// Root-nodes: Name of primary camera, if any
+    std::string mPrimaryCamera;
+
+    /// Constructor. Begin with a zero parent
+    Node() :
+            mParent(nullptr) {
+        // empty
+    }
+
+    /// Destructor: delete all children subsequently
+    ~Node() {
+        for (std::vector<Node *>::iterator it = mChildren.begin(); it != mChildren.end(); ++it) {
+            delete *it;
+        }
+    }
+};
+
+/// Data source array: either floats or strings
+struct Data {
+    bool mIsStringArray;
+    std::vector<ai_real> mValues;
+    std::vector<std::string> mStrings;
+};
+
+/// Accessor to a data array
+struct Accessor {
+    size_t mCount; // in number of objects
+    size_t mSize; // size of an object, in elements (floats or strings, mostly 1)
+    size_t mOffset; // in number of values
+    size_t mStride; // Stride in number of values
+    std::vector<std::string> mParams; // names of the data streams in the accessors. Empty string tells to ignore.
+    size_t mSubOffset[4]; // Sub-offset inside the object for the common 4 elements. For a vector, that's XYZ, for a color RGBA and so on.
+            // For example, SubOffset[0] denotes which of the values inside the object is the vector X component.
+    std::string mSource; // URL of the source array
+    mutable const Data *mData; // Pointer to the source array, if resolved. nullptr else
+
+    Accessor() {
+        mCount = 0;
+        mSize = 0;
+        mOffset = 0;
+        mStride = 0;
+        mData = nullptr;
+        mSubOffset[0] = mSubOffset[1] = mSubOffset[2] = mSubOffset[3] = 0;
+    }
+};
+
+/// A single face in a mesh
+struct Face {
+    std::vector<size_t> mIndices;
+};
+
+/// An input channel for mesh data, referring to a single accessor
+struct InputChannel {
+    InputType mType; // Type of the data
+    size_t mIndex; // Optional index, if multiple sets of the same data type are given
+    size_t mOffset; // Index offset in the indices array of per-face indices. Don't ask, can't explain that any better.
+    std::string mAccessor; // ID of the accessor where to read the actual values from.
+    mutable const Accessor *mResolved; // Pointer to the accessor, if resolved. nullptr else
+
+    InputChannel() {
+        mType = IT_Invalid;
+        mIndex = 0;
+        mOffset = 0;
+        mResolved = nullptr;
+    }
+};
+
+/// Subset of a mesh with a certain material
+struct SubMesh {
+    std::string mMaterial; ///< subgroup identifier
+    size_t mNumFaces; ///< number of faces in this sub-mesh
+};
+
+/// Contains data for a single mesh
+struct Mesh {
+    Mesh(const std::string &id) :
+            mId(id) {
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            mNumUVComponents[i] = 2;
+        }
+    }
+
+    const std::string mId;
+    std::string mName;
+
+    // just to check if there's some sophisticated addressing involved...
+    // which we don't support, and therefore should warn about.
+    std::string mVertexID;
+
+    // Vertex data addressed by vertex indices
+    std::vector<InputChannel> mPerVertexData;
+
+    // actual mesh data, assembled on encounter of a <p> element. Verbose format, not indexed
+    std::vector<aiVector3D> mPositions;
+    std::vector<aiVector3D> mNormals;
+    std::vector<aiVector3D> mTangents;
+    std::vector<aiVector3D> mBitangents;
+    std::vector<aiVector3D> mTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    std::vector<aiColor4D> mColors[AI_MAX_NUMBER_OF_COLOR_SETS];
+
+    unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+
+    // Faces. Stored are only the number of vertices for each face.
+    // 1 == point, 2 == line, 3 == triangle, 4+ == poly
+    std::vector<size_t> mFaceSize;
+
+    // Position indices for all faces in the sequence given in mFaceSize -
+    // necessary for bone weight assignment
+    std::vector<size_t> mFacePosIndices;
+
+    // Sub-meshes in this mesh, each with a given material
+    std::vector<SubMesh> mSubMeshes;
+};
+
+/// Which type of primitives the ReadPrimitives() function is going to read
+enum PrimitiveType {
+    Prim_Invalid,
+    Prim_Lines,
+    Prim_LineStrip,
+    Prim_Triangles,
+    Prim_TriStrips,
+    Prim_TriFans,
+    Prim_Polylist,
+    Prim_Polygon
+};
+
+/// A skeleton controller to deform a mesh with the use of joints
+struct Controller {
+    // controller type
+    ControllerType mType;
+
+    // Morphing method if type is Morph
+    MorphMethod mMethod;
+
+    // the URL of the mesh deformed by the controller.
+    std::string mMeshId;
+
+    // accessor URL of the joint names
+    std::string mJointNameSource;
+
+    ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases
+    ai_real mBindShapeMatrix[16];
+
+    // accessor URL of the joint inverse bind matrices
+    std::string mJointOffsetMatrixSource;
+
+    // input channel: joint names.
+    InputChannel mWeightInputJoints;
+    // input channel: joint weights
+    InputChannel mWeightInputWeights;
+
+    // Number of weights per vertex.
+    std::vector<size_t> mWeightCounts;
+
+    // JointIndex-WeightIndex pairs for all vertices
+    std::vector<std::pair<size_t, size_t>> mWeights;
+
+    std::string mMorphTarget;
+    std::string mMorphWeight;
+};
+
+/// A collada material. Pretty much the only member is a reference to an effect.
+struct Material {
+    std::string mName;
+    std::string mEffect;
+};
+
+/// Type of the effect param
+enum ParamType {
+    Param_Sampler,
+    Param_Surface
+};
+
+/// A param for an effect. Might be of several types, but they all just refer to each other, so I summarize them
+struct EffectParam {
+    ParamType mType;
+    std::string mReference; // to which other thing the param is referring to.
+};
+
+/// Shading type supported by the standard effect spec of Collada
+enum ShadeType {
+    Shade_Invalid,
+    Shade_Constant,
+    Shade_Lambert,
+    Shade_Phong,
+    Shade_Blinn
+};
+
+/// Represents a texture sampler in collada
+struct Sampler {
+    Sampler() :
+            mWrapU(true),
+            mWrapV(true),
+            mMirrorU(),
+            mMirrorV(),
+            mOp(aiTextureOp_Multiply),
+            mUVId(UINT_MAX),
+            mWeighting(1.f),
+            mMixWithPrevious(1.f) {}
+
+    /// Name of image reference
+    std::string mName;
+
+    /// Wrap U?
+    bool mWrapU;
+
+    /// Wrap V?
+    bool mWrapV;
+
+    /// Mirror U?
+    bool mMirrorU;
+
+    /// Mirror V?
+    bool mMirrorV;
+
+    /// Blend mode
+    aiTextureOp mOp;
+
+    /// UV transformation
+    aiUVTransform mTransform;
+
+    /// Name of source UV channel
+    std::string mUVChannel;
+
+    /// Resolved UV channel index or UINT_MAX if not known
+    unsigned int mUVId;
+
+    // OKINO/MAX3D extensions from here
+    // -------------------------------------------------------
+
+    /// Weighting factor
+    ai_real mWeighting;
+
+    /// Mixing factor from OKINO
+    ai_real mMixWithPrevious;
+};
+
+/// A collada effect. Can contain about anything according to the Collada spec,
+/// but we limit our version to a reasonable subset.
+struct Effect {
+    /// Shading mode
+    ShadeType mShadeType;
+
+    /// Colors
+    aiColor4D mEmissive, mAmbient, mDiffuse, mSpecular,
+            mTransparent, mReflective;
+
+    /// Textures
+    Sampler mTexEmissive, mTexAmbient, mTexDiffuse, mTexSpecular,
+            mTexTransparent, mTexBump, mTexReflective;
+
+    /// Scalar factory
+    ai_real mShininess, mRefractIndex, mReflectivity;
+    ai_real mTransparency;
+    bool mHasTransparency;
+    bool mRGBTransparency;
+    bool mInvertTransparency;
+
+    /// local params referring to each other by their SID
+    using ParamLibrary = std::map<std::string, Collada::EffectParam>;
+    ParamLibrary mParams;
+
+    // MAX3D extensions
+    // ---------------------------------------------------------
+    // Double-sided?
+    bool mDoubleSided, mWireframe, mFaceted;
+
+    Effect() :
+            mShadeType(Shade_Phong),
+            mEmissive(0, 0, 0, 1),
+            mAmbient(0.1f, 0.1f, 0.1f, 1),
+            mDiffuse(0.6f, 0.6f, 0.6f, 1),
+            mSpecular(0.4f, 0.4f, 0.4f, 1),
+            mTransparent(0, 0, 0, 1),
+            mShininess(10.0f),
+            mRefractIndex(1.f),
+            mReflectivity(0.f),
+            mTransparency(1.f),
+            mHasTransparency(false),
+            mRGBTransparency(false),
+            mInvertTransparency(false),
+            mDoubleSided(false),
+            mWireframe(false),
+            mFaceted(false) {
+    }
+};
+
+/// An image, meaning texture
+struct Image {
+    std::string mFileName;
+
+    /// Embedded image data
+    std::vector<uint8_t> mImageData;
+
+    /// File format hint of embedded image data
+    std::string mEmbeddedFormat;
+};
+
+/// An animation channel.
+struct AnimationChannel {
+    /// URL of the data to animate. Could be about anything, but we support only the
+    /// "NodeID/TransformID.SubElement" notation
+    std::string mTarget;
+
+    /// Source URL of the time values. Collada calls them "input". Meh.
+    std::string mSourceTimes;
+    /// Source URL of the value values. Collada calls them "output".
+    std::string mSourceValues;
+    /// Source URL of the IN_TANGENT semantic values.
+    std::string mInTanValues;
+    /// Source URL of the OUT_TANGENT semantic values.
+    std::string mOutTanValues;
+    /// Source URL of the INTERPOLATION semantic values.
+    std::string mInterpolationValues;
+};
+
+/// An animation. Container for 0-x animation channels or 0-x animations
+struct Animation {
+    /// Anim name
+    std::string mName;
+
+    /// the animation channels, if any
+    std::vector<AnimationChannel> mChannels;
+
+    /// the sub-animations, if any
+    std::vector<Animation *> mSubAnims;
+
+    /// Destructor
+    ~Animation() {
+        for (std::vector<Animation *>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) {
+            delete *it;
+        }
+    }
+
+    /// Collect all channels in the animation hierarchy into a single channel list.
+    void CollectChannelsRecursively(std::vector<AnimationChannel> &channels) {
+        channels.insert(channels.end(), mChannels.begin(), mChannels.end());
+
+        for (std::vector<Animation *>::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) {
+            Animation *pAnim = (*it);
+            pAnim->CollectChannelsRecursively(channels);
+        }
+    }
+
+    /// Combine all single-channel animations' channel into the same (parent) animation channel list.
+    void CombineSingleChannelAnimations() {
+        CombineSingleChannelAnimationsRecursively(this);
+    }
+
+    void CombineSingleChannelAnimationsRecursively(Animation *pParent) {
+        std::set<std::string> childrenTargets;
+        bool childrenAnimationsHaveDifferentChannels = true;
+
+        for (std::vector<Animation *>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) {
+            Animation *anim = *it;
+            CombineSingleChannelAnimationsRecursively(anim);
+
+            if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 &&
+                    childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) {
+                childrenTargets.insert(anim->mChannels[0].mTarget);
+            } else {
+                childrenAnimationsHaveDifferentChannels = false;
+            }
+
+            ++it;
+        }
+
+        // We only want to combine animations if they have different channels
+        if (childrenAnimationsHaveDifferentChannels) {
+            for (std::vector<Animation *>::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) {
+                Animation *anim = *it;
+
+                pParent->mChannels.push_back(anim->mChannels[0]);
+
+                it = pParent->mSubAnims.erase(it);
+
+                delete anim;
+                continue;
+            }
+        }
+    }
+};
+
+/// Description of a collada animation channel which has been determined to affect the current node
+struct ChannelEntry {
+    const Collada::AnimationChannel *mChannel; ///< the source channel
+    std::string mTargetId;
+    std::string mTransformId; // the ID of the transformation step of the node which is influenced
+    size_t mTransformIndex; // Index into the node's transform chain to apply the channel to
+    size_t mSubElement; // starting index inside the transform data
+
+    // resolved data references
+    const Collada::Accessor *mTimeAccessor; ///> Collada accessor to the time values
+    const Collada::Data *mTimeData; ///> Source data array for the time values
+    const Collada::Accessor *mValueAccessor; ///> Collada accessor to the key value values
+    const Collada::Data *mValueData; ///> Source datat array for the key value values
+
+    ChannelEntry() :
+            mChannel(),
+            mTransformIndex(),
+            mSubElement(),
+            mTimeAccessor(),
+            mTimeData(),
+            mValueAccessor(),
+            mValueData() {}
+};
+
+} // end of namespace Collada
+} // end of namespace Assimp
+
+#endif // AI_COLLADAHELPER_H_INC
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp
new file mode 100644
index 0000000..775ba44
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp
@@ -0,0 +1,1828 @@
+/*
+---------------------------------------------------------------------------
+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 Collada loader */
+
+#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
+
+#include "ColladaLoader.h"
+#include "ColladaParser.h"
+#include <assimp/ColladaMetaData.h>
+#include <assimp/CreateAnimMesh.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/anim.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+
+#include <numeric>
+
+namespace Assimp {
+
+using namespace Assimp::Formatter;
+using namespace Assimp::Collada;
+
+static const aiImporterDesc desc = {
+    "Collada Importer",
+    "",
+    "",
+    "http://collada.org",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour,
+    1,
+    3,
+    1,
+    5,
+    "dae xml zae"
+};
+
+static const float kMillisecondsFromSeconds = 1000.f;
+
+// Add an item of metadata to a node
+// Assumes the key is not already in the list
+template <typename T>
+inline void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) {
+    if (nullptr == node->mMetaData) {
+        node->mMetaData = new aiMetadata();
+    }
+    node->mMetaData->Add(key, value);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+ColladaLoader::ColladaLoader() :
+        mFileName(),
+        mMeshIndexByID(),
+        mMaterialIndexByName(),
+        mMeshes(),
+        newMats(),
+        mCameras(),
+        mLights(),
+        mTextures(),
+        mAnims(),
+        noSkeletonMesh(false),
+        ignoreUpDirection(false),
+        useColladaName(false),
+        mNodeNameCounter(0) {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+ColladaLoader::~ColladaLoader() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    // Look for a DAE file inside, but don't extract it
+    ZipArchiveIOSystem zip_archive(pIOHandler, pFile);
+    if (zip_archive.isOpen()) {
+        return !ColladaParser::ReadZaeManifest(zip_archive).empty();
+    }
+
+    static const char *tokens[] = { "<collada" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+void ColladaLoader::SetupProperties(const Importer *pImp) {
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
+    ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION, 0) != 0;
+    useColladaName = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES, 0) != 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get file extension list
+const aiImporterDesc *ColladaLoader::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    mFileName = pFile;
+
+    // clean all member arrays - just for safety, it should work even if we did not
+    mMeshIndexByID.clear();
+    mMaterialIndexByName.clear();
+    mMeshes.clear();
+    mTargetMeshes.clear();
+    newMats.clear();
+    mLights.clear();
+    mCameras.clear();
+    mTextures.clear();
+    mAnims.clear();
+
+    // parse the input file
+    ColladaParser parser(pIOHandler, pFile);
+
+    if (!parser.mRootNode) {
+        throw DeadlyImportError("Collada: File came out empty. Something is wrong here.");
+    }
+
+    // reserve some storage to avoid unnecessary reallocs
+    newMats.reserve(parser.mMaterialLibrary.size() * 2u);
+    mMeshes.reserve(parser.mMeshLibrary.size() * 2u);
+
+    mCameras.reserve(parser.mCameraLibrary.size());
+    mLights.reserve(parser.mLightLibrary.size());
+
+    // create the materials first, for the meshes to find
+    BuildMaterials(parser, pScene);
+
+    // build the node hierarchy from it
+    pScene->mRootNode = BuildHierarchy(parser, parser.mRootNode);
+
+    // ... then fill the materials with the now adjusted settings
+    FillMaterials(parser, pScene);
+
+    // Apply unit-size scale calculation
+
+    pScene->mRootNode->mTransformation *= aiMatrix4x4(parser.mUnitSize, 0, 0, 0,
+            0, parser.mUnitSize, 0, 0,
+            0, 0, parser.mUnitSize, 0,
+            0, 0, 0, 1);
+    if (!ignoreUpDirection) {
+        // Convert to Y_UP, if different orientation
+        if (parser.mUpDirection == ColladaParser::UP_X) {
+            pScene->mRootNode->mTransformation *= aiMatrix4x4(
+                    0, -1, 0, 0,
+                    1, 0, 0, 0,
+                    0, 0, 1, 0,
+                    0, 0, 0, 1);
+        } else if (parser.mUpDirection == ColladaParser::UP_Z) {
+            pScene->mRootNode->mTransformation *= aiMatrix4x4(
+                    1, 0, 0, 0,
+                    0, 0, 1, 0,
+                    0, -1, 0, 0,
+                    0, 0, 0, 1);
+        }
+    }
+
+    // Store scene metadata
+    if (!parser.mAssetMetaData.empty()) {
+        const size_t numMeta(parser.mAssetMetaData.size());
+        pScene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(numMeta));
+        size_t i = 0;
+        for (auto it = parser.mAssetMetaData.cbegin(); it != parser.mAssetMetaData.cend(); ++it, ++i) {
+            pScene->mMetaData->Set(static_cast<unsigned int>(i), (*it).first, (*it).second);
+        }
+    }
+
+    StoreSceneMeshes(pScene);
+    StoreSceneMaterials(pScene);
+    StoreSceneTextures(pScene);
+    StoreSceneLights(pScene);
+    StoreSceneCameras(pScene);
+    StoreAnimations(pScene, parser);
+
+    // If no meshes have been loaded, it's probably just an animated skeleton.
+    if (0u == pScene->mNumMeshes) {
+        if (!noSkeletonMesh) {
+            SkeletonMeshBuilder hero(pScene);
+        }
+        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Recursively constructs a scene node for the given parser node and returns it.
+aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode) {
+    // create a node for it
+    aiNode *node = new aiNode();
+
+    // find a name for the new node. It's more complicated than you might think
+    node->mName.Set(FindNameForNode(pNode));
+    // if we're not using the unique IDs, hold onto them for reference and export
+    if (useColladaName) {
+        if (!pNode->mID.empty()) {
+            AddNodeMetaData(node, AI_METADATA_COLLADA_ID, aiString(pNode->mID));
+        }
+        if (!pNode->mSID.empty()) {
+            AddNodeMetaData(node, AI_METADATA_COLLADA_SID, aiString(pNode->mSID));
+        }
+    }
+
+    // calculate the transformation matrix for it
+    node->mTransformation = pParser.CalculateResultTransform(pNode->mTransforms);
+
+    // now resolve node instances
+    std::vector<const Node*> instances;
+    ResolveNodeInstances(pParser, pNode, instances);
+
+    // add children. first the *real* ones
+    node->mNumChildren = static_cast<unsigned int>(pNode->mChildren.size() + instances.size());
+    node->mChildren = new aiNode *[node->mNumChildren];
+
+    for (size_t a = 0; a < pNode->mChildren.size(); ++a) {
+        node->mChildren[a] = BuildHierarchy(pParser, pNode->mChildren[a]);
+        node->mChildren[a]->mParent = node;
+    }
+
+    // ... and finally the resolved node instances
+    for (size_t a = 0; a < instances.size(); ++a) {
+        node->mChildren[pNode->mChildren.size() + a] = BuildHierarchy(pParser, instances[a]);
+        node->mChildren[pNode->mChildren.size() + a]->mParent = node;
+    }
+
+    BuildMeshesForNode(pParser, pNode, node);
+    BuildCamerasForNode(pParser, pNode, node);
+    BuildLightsForNode(pParser, pNode, node);
+
+    return node;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Resolve node instances
+void ColladaLoader::ResolveNodeInstances(const ColladaParser &pParser, const Node *pNode,
+        std::vector<const Node*> &resolved) {
+    // reserve enough storage
+    resolved.reserve(pNode->mNodeInstances.size());
+
+    // ... and iterate through all nodes to be instanced as children of pNode
+    for (const auto &nodeInst : pNode->mNodeInstances) {
+        // find the corresponding node in the library
+        const ColladaParser::NodeLibrary::const_iterator itt = pParser.mNodeLibrary.find(nodeInst.mNode);
+        const Node *nd = itt == pParser.mNodeLibrary.end() ? nullptr : (*itt).second;
+
+        // FIX for http://sourceforge.net/tracker/?func=detail&aid=3054873&group_id=226462&atid=1067632
+        // need to check for both name and ID to catch all. To avoid breaking valid files,
+        // the workaround is only enabled when the first attempt to resolve the node has failed.
+        if (nullptr == nd) {
+            nd = FindNode(pParser.mRootNode, nodeInst.mNode);
+        }
+        if (nullptr == nd) {
+            ASSIMP_LOG_ERROR("Collada: Unable to resolve reference to instanced node ", nodeInst.mNode);
+        } else {
+            //  attach this node to the list of children
+            resolved.push_back(nd);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Resolve UV channels
+void ColladaLoader::ApplyVertexToEffectSemanticMapping(Sampler &sampler, const SemanticMappingTable &table) {
+    SemanticMappingTable::InputSemanticMap::const_iterator it = table.mMap.find(sampler.mUVChannel);
+    if (it == table.mMap.end()) {
+        return;
+    }
+
+    if (it->second.mType != IT_Texcoord) {
+        ASSIMP_LOG_ERROR("Collada: Unexpected effect input mapping");
+    }
+
+    sampler.mUVId = it->second.mSet;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Builds lights for the given node and references them
+void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
+    for (const LightInstance &lid : pNode->mLights) {
+        // find the referred light
+        ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find(lid.mLight);
+        if (srcLightIt == pParser.mLightLibrary.end()) {
+            ASSIMP_LOG_WARN("Collada: Unable to find light for ID \"", lid.mLight, "\". Skipping.");
+            continue;
+        }
+        const Collada::Light *srcLight = &srcLightIt->second;
+
+        // now fill our ai data structure
+        aiLight *out = new aiLight();
+        out->mName = pTarget->mName;
+        out->mType = (aiLightSourceType)srcLight->mType;
+
+        // collada lights point in -Z by default, rest is specified in node transform
+        out->mDirection = aiVector3D(0.f, 0.f, -1.f);
+
+        out->mAttenuationConstant = srcLight->mAttConstant;
+        out->mAttenuationLinear = srcLight->mAttLinear;
+        out->mAttenuationQuadratic = srcLight->mAttQuadratic;
+
+        out->mColorDiffuse = out->mColorSpecular = out->mColorAmbient = srcLight->mColor * srcLight->mIntensity;
+        if (out->mType == aiLightSource_AMBIENT) {
+            out->mColorDiffuse = out->mColorSpecular = aiColor3D(0, 0, 0);
+            out->mColorAmbient = srcLight->mColor * srcLight->mIntensity;
+        } else {
+            // collada doesn't differentiate between these color types
+            out->mColorDiffuse = out->mColorSpecular = srcLight->mColor * srcLight->mIntensity;
+            out->mColorAmbient = aiColor3D(0, 0, 0);
+        }
+
+        // convert falloff angle and falloff exponent in our representation, if given
+        if (out->mType == aiLightSource_SPOT) {
+            out->mAngleInnerCone = AI_DEG_TO_RAD(srcLight->mFalloffAngle);
+
+            // ... some extension magic.
+            if (srcLight->mOuterAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) {
+                // ... some deprecation magic.
+                if (srcLight->mPenumbraAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) {
+                    // Need to rely on falloff_exponent. I don't know how to interpret it, so I need to guess ....
+                    // epsilon chosen to be 0.1
+                    float f = 1.0f;
+                    if ( 0.0f != srcLight->mFalloffExponent ) {
+                        f = 1.f / srcLight->mFalloffExponent;
+                    }
+                    out->mAngleOuterCone = std::acos(std::pow(0.1f, f)) +
+                                           out->mAngleInnerCone;
+                } else {
+                    out->mAngleOuterCone = out->mAngleInnerCone + AI_DEG_TO_RAD(srcLight->mPenumbraAngle);
+                    if (out->mAngleOuterCone < out->mAngleInnerCone)
+                        std::swap(out->mAngleInnerCone, out->mAngleOuterCone);
+                }
+            } else {
+                out->mAngleOuterCone = AI_DEG_TO_RAD(srcLight->mOuterAngle);
+            }
+        }
+
+        // add to light list
+        mLights.push_back(out);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Builds cameras for the given node and references them
+void ColladaLoader::BuildCamerasForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
+    for (const CameraInstance &cid : pNode->mCameras) {
+        // find the referred light
+        ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find(cid.mCamera);
+        if (srcCameraIt == pParser.mCameraLibrary.end()) {
+            ASSIMP_LOG_WARN("Collada: Unable to find camera for ID \"", cid.mCamera, "\". Skipping.");
+            continue;
+        }
+        const Collada::Camera *srcCamera = &srcCameraIt->second;
+
+        // orthographic cameras not yet supported in Assimp
+        if (srcCamera->mOrtho) {
+            ASSIMP_LOG_WARN("Collada: Orthographic cameras are not supported.");
+        }
+
+        // now fill our ai data structure
+        aiCamera *out = new aiCamera();
+        out->mName = pTarget->mName;
+
+        // collada cameras point in -Z by default, rest is specified in node transform
+        out->mLookAt = aiVector3D(0.f, 0.f, -1.f);
+
+        // near/far z is already ok
+        out->mClipPlaneFar = srcCamera->mZFar;
+        out->mClipPlaneNear = srcCamera->mZNear;
+
+        // ... but for the rest some values are optional
+        // and we need to compute the others in any combination.
+        if (srcCamera->mAspect != 10e10f) {
+            out->mAspect = srcCamera->mAspect;
+        }
+
+        if (srcCamera->mHorFov != 10e10f) {
+            out->mHorizontalFOV = srcCamera->mHorFov;
+
+            if (srcCamera->mVerFov != 10e10f && srcCamera->mAspect == 10e10f) {
+                out->mAspect = std::tan(AI_DEG_TO_RAD(srcCamera->mHorFov)) /
+                               std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov));
+            }
+
+        } else if (srcCamera->mAspect != 10e10f && srcCamera->mVerFov != 10e10f) {
+            out->mHorizontalFOV = 2.0f * AI_RAD_TO_DEG(std::atan(srcCamera->mAspect *
+                                                                 std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov) * 0.5f)));
+        }
+
+        // Collada uses degrees, we use radians
+        out->mHorizontalFOV = AI_DEG_TO_RAD(out->mHorizontalFOV);
+
+        // add to camera list
+        mCameras.push_back(out);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Builds meshes for the given node and references them
+void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) {
+    // accumulated mesh references by this node
+    std::vector<size_t> newMeshRefs;
+    newMeshRefs.reserve(pNode->mMeshes.size());
+
+    // add a mesh for each subgroup in each collada mesh
+    for (const MeshInstance &mid : pNode->mMeshes) {
+        const Mesh *srcMesh = nullptr;
+        const Controller *srcController = nullptr;
+
+        // find the referred mesh
+        ColladaParser::MeshLibrary::const_iterator srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController);
+        if (srcMeshIt == pParser.mMeshLibrary.end()) {
+            // if not found in the mesh-library, it might also be a controller referring to a mesh
+            ColladaParser::ControllerLibrary::const_iterator srcContrIt = pParser.mControllerLibrary.find(mid.mMeshOrController);
+            if (srcContrIt != pParser.mControllerLibrary.end()) {
+                srcController = &srcContrIt->second;
+                srcMeshIt = pParser.mMeshLibrary.find(srcController->mMeshId);
+                if (srcMeshIt != pParser.mMeshLibrary.end()) {
+                    srcMesh = srcMeshIt->second;
+                }
+            }
+
+            if (nullptr == srcMesh) {
+                ASSIMP_LOG_WARN("Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping.");
+                continue;
+            }
+        } else {
+            // ID found in the mesh library -> direct reference to an unskinned mesh
+            srcMesh = srcMeshIt->second;
+        }
+
+        // build a mesh for each of its subgroups
+        size_t vertexStart = 0, faceStart = 0;
+        for (size_t sm = 0; sm < srcMesh->mSubMeshes.size(); ++sm) {
+            const Collada::SubMesh &submesh = srcMesh->mSubMeshes[sm];
+            if (submesh.mNumFaces == 0) {
+                continue;
+            }
+
+            // find material assigned to this submesh
+            std::string meshMaterial;
+            std::map<std::string, SemanticMappingTable>::const_iterator meshMatIt = mid.mMaterials.find(submesh.mMaterial);
+
+            const Collada::SemanticMappingTable *table = nullptr;
+            if (meshMatIt != mid.mMaterials.end()) {
+                table = &meshMatIt->second;
+                meshMaterial = table->mMatName;
+            } else {
+                ASSIMP_LOG_WARN("Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <",
+                        mid.mMeshOrController, ">.");
+                if (!mid.mMaterials.empty()) {
+                    meshMaterial = mid.mMaterials.begin()->second.mMatName;
+                }
+            }
+
+            // OK ... here the *real* fun starts ... we have the vertex-input-to-effect-semantic-table
+            // given. The only mapping stuff which we do actually support is the UV channel.
+            std::map<std::string, size_t>::const_iterator matIt = mMaterialIndexByName.find(meshMaterial);
+            unsigned int matIdx = 0;
+            if (matIt != mMaterialIndexByName.end()) {
+                matIdx = static_cast<unsigned int>(matIt->second);
+            }
+
+            if (table && !table->mMap.empty()) {
+                std::pair<Collada::Effect *, aiMaterial *> &mat = newMats[matIdx];
+
+                // Iterate through all texture channels assigned to the effect and
+                // check whether we have mapping information for it.
+                ApplyVertexToEffectSemanticMapping(mat.first->mTexDiffuse, *table);
+                ApplyVertexToEffectSemanticMapping(mat.first->mTexAmbient, *table);
+                ApplyVertexToEffectSemanticMapping(mat.first->mTexSpecular, *table);
+                ApplyVertexToEffectSemanticMapping(mat.first->mTexEmissive, *table);
+                ApplyVertexToEffectSemanticMapping(mat.first->mTexTransparent, *table);
+                ApplyVertexToEffectSemanticMapping(mat.first->mTexBump, *table);
+            }
+
+            // built lookup index of the Mesh-Submesh-Material combination
+            ColladaMeshIndex index(mid.mMeshOrController, sm, meshMaterial);
+
+            // if we already have the mesh at the library, just add its index to the node's array
+            std::map<ColladaMeshIndex, size_t>::const_iterator dstMeshIt = mMeshIndexByID.find(index);
+            if (dstMeshIt != mMeshIndexByID.end()) {
+                newMeshRefs.push_back(dstMeshIt->second);
+            } else {
+                // else we have to add the mesh to the collection and store its newly assigned index at the node
+                aiMesh *dstMesh = CreateMesh(pParser, srcMesh, submesh, srcController, vertexStart, faceStart);
+
+                // store the mesh, and store its new index in the node
+                newMeshRefs.push_back(mMeshes.size());
+                mMeshIndexByID[index] = mMeshes.size();
+                mMeshes.push_back(dstMesh);
+                vertexStart += dstMesh->mNumVertices;
+                faceStart += submesh.mNumFaces;
+
+                // assign the material index
+                std::map<std::string, size_t>::const_iterator subMatIt = mMaterialIndexByName.find(submesh.mMaterial);
+                if (subMatIt != mMaterialIndexByName.end()) {
+                    dstMesh->mMaterialIndex = static_cast<unsigned int>(subMatIt->second);
+                } else {
+                    dstMesh->mMaterialIndex = matIdx;
+                }
+                if (dstMesh->mName.length == 0) {
+                    dstMesh->mName = mid.mMeshOrController;
+                }
+            }
+        }
+    }
+
+    // now place all mesh references we gathered in the target node
+    pTarget->mNumMeshes = static_cast<unsigned int>(newMeshRefs.size());
+    if (!newMeshRefs.empty()) {
+        struct UIntTypeConverter {
+            unsigned int operator()(const size_t &v) const {
+                return static_cast<unsigned int>(v);
+            }
+        };
+
+        pTarget->mMeshes = new unsigned int[pTarget->mNumMeshes];
+        std::transform(newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes, UIntTypeConverter());
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Find mesh from either meshes or morph target meshes
+aiMesh *ColladaLoader::findMesh(const std::string &meshid) {
+    if (meshid.empty()) {
+        return nullptr;
+    }
+
+    for (auto & mMeshe : mMeshes) {
+        if (std::string(mMeshe->mName.data) == meshid) {
+            return mMeshe;
+        }
+    }
+
+    for (auto & mTargetMeshe : mTargetMeshes) {
+        if (std::string(mTargetMeshe->mName.data) == meshid) {
+            return mTargetMeshe;
+        }
+    }
+
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh
+aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrcMesh, const SubMesh &pSubMesh,
+        const Controller *pSrcController, size_t pStartVertex, size_t pStartFace) {
+    std::unique_ptr<aiMesh> dstMesh(new aiMesh);
+
+    if (useColladaName) {
+        dstMesh->mName = pSrcMesh->mName;
+    } else {
+        dstMesh->mName = pSrcMesh->mId;
+    }
+
+    if (pSrcMesh->mPositions.empty()) {
+        return dstMesh.release();
+    }
+
+    // count the vertices addressed by its faces
+    const size_t numVertices = std::accumulate(pSrcMesh->mFaceSize.begin() + pStartFace,
+            pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0));
+
+    // copy positions
+    dstMesh->mNumVertices = static_cast<unsigned int>(numVertices);
+    dstMesh->mVertices = new aiVector3D[numVertices];
+    std::copy(pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() + pStartVertex + numVertices, dstMesh->mVertices);
+
+    // normals, if given. HACK: (thom) Due to the glorious Collada spec we never
+    // know if we have the same number of normals as there are positions. So we
+    // also ignore any vertex attribute if it has a different count
+    if (pSrcMesh->mNormals.size() >= pStartVertex + numVertices) {
+        dstMesh->mNormals = new aiVector3D[numVertices];
+        std::copy(pSrcMesh->mNormals.begin() + pStartVertex, pSrcMesh->mNormals.begin() + pStartVertex + numVertices, dstMesh->mNormals);
+    }
+
+    // tangents, if given.
+    if (pSrcMesh->mTangents.size() >= pStartVertex + numVertices) {
+        dstMesh->mTangents = new aiVector3D[numVertices];
+        std::copy(pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() + pStartVertex + numVertices, dstMesh->mTangents);
+    }
+
+    // bitangents, if given.
+    if (pSrcMesh->mBitangents.size() >= pStartVertex + numVertices) {
+        dstMesh->mBitangents = new aiVector3D[numVertices];
+        std::copy(pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() + pStartVertex + numVertices, dstMesh->mBitangents);
+    }
+
+    // same for texture coords, as many as we have
+    // empty slots are not allowed, need to pack and adjust UV indexes accordingly
+    for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices) {
+            dstMesh->mTextureCoords[real] = new aiVector3D[numVertices];
+            for (size_t b = 0; b < numVertices; ++b) {
+                dstMesh->mTextureCoords[real][b] = pSrcMesh->mTexCoords[a][pStartVertex + b];
+            }
+
+            dstMesh->mNumUVComponents[real] = pSrcMesh->mNumUVComponents[a];
+            ++real;
+        }
+    }
+
+    // same for vertex colors, as many as we have. again the same packing to avoid empty slots
+    for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+        if (pSrcMesh->mColors[a].size() >= pStartVertex + numVertices) {
+            dstMesh->mColors[real] = new aiColor4D[numVertices];
+            std::copy(pSrcMesh->mColors[a].begin() + pStartVertex, pSrcMesh->mColors[a].begin() + pStartVertex + numVertices, dstMesh->mColors[real]);
+            ++real;
+        }
+    }
+
+    // create faces. Due to the fact that each face uses unique vertices, we can simply count up on each vertex
+    size_t vertex = 0;
+    dstMesh->mNumFaces = static_cast<unsigned int>(pSubMesh.mNumFaces);
+    dstMesh->mFaces = new aiFace[dstMesh->mNumFaces];
+    for (size_t a = 0; a < dstMesh->mNumFaces; ++a) {
+        size_t s = pSrcMesh->mFaceSize[pStartFace + a];
+        aiFace &face = dstMesh->mFaces[a];
+        face.mNumIndices = static_cast<unsigned int>(s);
+        face.mIndices = new unsigned int[s];
+        for (size_t b = 0; b < s; ++b) {
+            face.mIndices[b] = static_cast<unsigned int>(vertex++);
+        }
+    }
+
+    // create morph target meshes if any
+    std::vector<aiMesh *> targetMeshes;
+    std::vector<float> targetWeights;
+    Collada::MorphMethod method = Normalized;
+
+    for (std::map<std::string, Controller>::const_iterator it = pParser.mControllerLibrary.begin();
+            it != pParser.mControllerLibrary.end(); ++it) {
+        const Controller &c = it->second;
+        const Collada::Mesh *baseMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, c.mMeshId);
+
+        if (c.mType == Collada::Morph && baseMesh->mName == pSrcMesh->mName) {
+            const Collada::Accessor &targetAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphTarget);
+            const Collada::Accessor &weightAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphWeight);
+            const Collada::Data &targetData = pParser.ResolveLibraryReference(pParser.mDataLibrary, targetAccessor.mSource);
+            const Collada::Data &weightData = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightAccessor.mSource);
+
+            // take method
+            method = c.mMethod;
+
+            if (!targetData.mIsStringArray) {
+                throw DeadlyImportError("target data must contain id. ");
+            }
+            if (weightData.mIsStringArray) {
+                throw DeadlyImportError("target weight data must not be textual ");
+            }
+
+            for (const auto & mString : targetData.mStrings) {
+                const Mesh *targetMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, mString);
+
+                aiMesh *aimesh = findMesh(useColladaName ? targetMesh->mName : targetMesh->mId);
+                if (!aimesh) {
+                    if (targetMesh->mSubMeshes.size() > 1) {
+                        throw DeadlyImportError("Morphing target mesh must be a single");
+                    }
+                    aimesh = CreateMesh(pParser, targetMesh, targetMesh->mSubMeshes.at(0), nullptr, 0, 0);
+                    mTargetMeshes.push_back(aimesh);
+                }
+                targetMeshes.push_back(aimesh);
+            }
+            for (float mValue : weightData.mValues) {
+                targetWeights.push_back(mValue);
+            }
+        }
+    }
+    if (!targetMeshes.empty() && targetWeights.size() == targetMeshes.size()) {
+        std::vector<aiAnimMesh *> animMeshes;
+        for (unsigned int i = 0; i < targetMeshes.size(); ++i) {
+            aiMesh *targetMesh = targetMeshes.at(i);
+            aiAnimMesh *animMesh = aiCreateAnimMesh(targetMesh);
+            float weight = targetWeights[i];
+            animMesh->mWeight = weight == 0 ? 1.0f : weight;
+            animMesh->mName = targetMesh->mName;
+            animMeshes.push_back(animMesh);
+        }
+        dstMesh->mMethod = (method == Relative) ? aiMorphingMethod_MORPH_RELATIVE : aiMorphingMethod_MORPH_NORMALIZED;
+        dstMesh->mAnimMeshes = new aiAnimMesh *[animMeshes.size()];
+        dstMesh->mNumAnimMeshes = static_cast<unsigned int>(animMeshes.size());
+        for (unsigned int i = 0; i < animMeshes.size(); ++i) {
+            dstMesh->mAnimMeshes[i] = animMeshes.at(i);
+        }
+    }
+
+    // create bones if given
+    if (pSrcController && pSrcController->mType == Collada::Skin) {
+        // resolve references - joint names
+        const Collada::Accessor &jointNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointNameSource);
+        const Collada::Data &jointNames = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointNamesAcc.mSource);
+        // joint offset matrices
+        const Collada::Accessor &jointMatrixAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointOffsetMatrixSource);
+        const Collada::Data &jointMatrices = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointMatrixAcc.mSource);
+        // joint vertex_weight name list - should refer to the same list as the joint names above. If not, report and reconsider
+        const Collada::Accessor &weightNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor);
+        if (&weightNamesAcc != &jointNamesAcc)
+            throw DeadlyImportError("Temporary implementational laziness. If you read this, please report to the author.");
+        // vertex weights
+        const Collada::Accessor &weightsAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor);
+        const Collada::Data &weights = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightsAcc.mSource);
+
+        if (!jointNames.mIsStringArray || jointMatrices.mIsStringArray || weights.mIsStringArray) {
+            throw DeadlyImportError("Data type mismatch while resolving mesh joints");
+        }
+        // sanity check: we rely on the vertex weights always coming as pairs of BoneIndex-WeightIndex
+        if (pSrcController->mWeightInputJoints.mOffset != 0 || pSrcController->mWeightInputWeights.mOffset != 1) {
+            throw DeadlyImportError("Unsupported vertex_weight addressing scheme. ");
+        }
+
+        // create containers to collect the weights for each bone
+        size_t numBones = jointNames.mStrings.size();
+        std::vector<std::vector<aiVertexWeight>> dstBones(numBones);
+
+        // build a temporary array of pointers to the start of each vertex's weights
+        using IndexPairVector = std::vector<std::pair<size_t, size_t>>;
+        std::vector<IndexPairVector::const_iterator> weightStartPerVertex;
+        weightStartPerVertex.resize(pSrcController->mWeightCounts.size(), pSrcController->mWeights.end());
+
+        IndexPairVector::const_iterator pit = pSrcController->mWeights.begin();
+        for (size_t a = 0; a < pSrcController->mWeightCounts.size(); ++a) {
+            weightStartPerVertex[a] = pit;
+            pit += pSrcController->mWeightCounts[a];
+        }
+
+        // now for each vertex put the corresponding vertex weights into each bone's weight collection
+        for (size_t a = pStartVertex; a < pStartVertex + numVertices; ++a) {
+            // which position index was responsible for this vertex? that's also the index by which
+            // the controller assigns the vertex weights
+            size_t orgIndex = pSrcMesh->mFacePosIndices[a];
+            // find the vertex weights for this vertex
+            IndexPairVector::const_iterator iit = weightStartPerVertex[orgIndex];
+            size_t pairCount = pSrcController->mWeightCounts[orgIndex];
+
+            for (size_t b = 0; b < pairCount; ++b, ++iit) {
+                const size_t jointIndex = iit->first;
+                const size_t vertexIndex = iit->second;
+                ai_real weight = 1.0f;
+                if (!weights.mValues.empty()) {
+                    weight = ReadFloat(weightsAcc, weights, vertexIndex, 0);
+                }
+
+                // one day I gonna kill that XSI Collada exporter
+                if (weight > 0.0f) {
+                    aiVertexWeight w;
+                    w.mVertexId = static_cast<unsigned int>(a - pStartVertex);
+                    w.mWeight = weight;
+                    dstBones[jointIndex].push_back(w);
+                }
+            }
+        }
+
+        // count the number of bones which influence vertices of the current submesh
+        size_t numRemainingBones = 0;
+        for (const auto & dstBone : dstBones) {
+            if (!dstBone.empty()) {
+                ++numRemainingBones;
+            }
+        }
+
+        // create bone array and copy bone weights one by one
+        dstMesh->mNumBones = static_cast<unsigned int>(numRemainingBones);
+        dstMesh->mBones = new aiBone *[numRemainingBones];
+        size_t boneCount = 0;
+        for (size_t a = 0; a < numBones; ++a) {
+            // omit bones without weights
+            if (dstBones[a].empty()) {
+                continue;
+            }
+
+            // create bone with its weights
+            aiBone *bone = new aiBone;
+            bone->mName = ReadString(jointNamesAcc, jointNames, a);
+            bone->mOffsetMatrix.a1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 0);
+            bone->mOffsetMatrix.a2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 1);
+            bone->mOffsetMatrix.a3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 2);
+            bone->mOffsetMatrix.a4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 3);
+            bone->mOffsetMatrix.b1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 4);
+            bone->mOffsetMatrix.b2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 5);
+            bone->mOffsetMatrix.b3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 6);
+            bone->mOffsetMatrix.b4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 7);
+            bone->mOffsetMatrix.c1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 8);
+            bone->mOffsetMatrix.c2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 9);
+            bone->mOffsetMatrix.c3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 10);
+            bone->mOffsetMatrix.c4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 11);
+            bone->mNumWeights = static_cast<unsigned int>(dstBones[a].size());
+            bone->mWeights = new aiVertexWeight[bone->mNumWeights];
+            std::copy(dstBones[a].begin(), dstBones[a].end(), bone->mWeights);
+
+            // apply bind shape matrix to offset matrix
+            aiMatrix4x4 bindShapeMatrix;
+            bindShapeMatrix.a1 = pSrcController->mBindShapeMatrix[0];
+            bindShapeMatrix.a2 = pSrcController->mBindShapeMatrix[1];
+            bindShapeMatrix.a3 = pSrcController->mBindShapeMatrix[2];
+            bindShapeMatrix.a4 = pSrcController->mBindShapeMatrix[3];
+            bindShapeMatrix.b1 = pSrcController->mBindShapeMatrix[4];
+            bindShapeMatrix.b2 = pSrcController->mBindShapeMatrix[5];
+            bindShapeMatrix.b3 = pSrcController->mBindShapeMatrix[6];
+            bindShapeMatrix.b4 = pSrcController->mBindShapeMatrix[7];
+            bindShapeMatrix.c1 = pSrcController->mBindShapeMatrix[8];
+            bindShapeMatrix.c2 = pSrcController->mBindShapeMatrix[9];
+            bindShapeMatrix.c3 = pSrcController->mBindShapeMatrix[10];
+            bindShapeMatrix.c4 = pSrcController->mBindShapeMatrix[11];
+            bindShapeMatrix.d1 = pSrcController->mBindShapeMatrix[12];
+            bindShapeMatrix.d2 = pSrcController->mBindShapeMatrix[13];
+            bindShapeMatrix.d3 = pSrcController->mBindShapeMatrix[14];
+            bindShapeMatrix.d4 = pSrcController->mBindShapeMatrix[15];
+            bone->mOffsetMatrix *= bindShapeMatrix;
+
+            // HACK: (thom) Some exporters address the bone nodes by SID, others address them by ID or even name.
+            // Therefore I added a little name replacement here: I search for the bone's node by either name, ID or SID,
+            // and replace the bone's name by the node's name so that the user can use the standard
+            // find-by-name method to associate nodes with bones.
+            const Collada::Node *bnode = FindNode(pParser.mRootNode, bone->mName.data);
+            if (nullptr == bnode) {
+                bnode = FindNodeBySID(pParser.mRootNode, bone->mName.data);
+            }
+
+            // assign the name that we would have assigned for the source node
+            if (nullptr != bnode) {
+                bone->mName.Set(FindNameForNode(bnode));
+            } else {
+                ASSIMP_LOG_WARN("ColladaLoader::CreateMesh(): could not find corresponding node for joint \"", bone->mName.data, "\".");
+            }
+
+            // and insert bone
+            dstMesh->mBones[boneCount++] = bone;
+        }
+    }
+
+    return dstMesh.release();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Stores all meshes in the given scene
+void ColladaLoader::StoreSceneMeshes(aiScene *pScene) {
+    pScene->mNumMeshes = static_cast<unsigned int>(mMeshes.size());
+    if (mMeshes.empty()) {
+        return;
+    }
+    pScene->mMeshes = new aiMesh *[mMeshes.size()];
+    std::copy(mMeshes.begin(), mMeshes.end(), pScene->mMeshes);
+    mMeshes.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Stores all cameras in the given scene
+void ColladaLoader::StoreSceneCameras(aiScene *pScene) {
+    pScene->mNumCameras = static_cast<unsigned int>(mCameras.size());
+    if (mCameras.empty()) {
+        return;
+    }
+    pScene->mCameras = new aiCamera *[mCameras.size()];
+    std::copy(mCameras.begin(), mCameras.end(), pScene->mCameras);
+    mCameras.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Stores all lights in the given scene
+void ColladaLoader::StoreSceneLights(aiScene *pScene) {
+    pScene->mNumLights = static_cast<unsigned int>(mLights.size());
+    if (mLights.empty()) {
+        return;
+    }
+    pScene->mLights = new aiLight *[mLights.size()];
+    std::copy(mLights.begin(), mLights.end(), pScene->mLights);
+    mLights.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Stores all textures in the given scene
+void ColladaLoader::StoreSceneTextures(aiScene *pScene) {
+    pScene->mNumTextures = static_cast<unsigned int>(mTextures.size());
+    if (mTextures.empty()) {
+        return;
+    }
+    pScene->mTextures = new aiTexture *[mTextures.size()];
+    std::copy(mTextures.begin(), mTextures.end(), pScene->mTextures);
+    mTextures.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Stores all materials in the given scene
+void ColladaLoader::StoreSceneMaterials(aiScene *pScene) {
+    pScene->mNumMaterials = static_cast<unsigned int>(newMats.size());
+    if (newMats.empty()) {
+        return;
+    }
+    pScene->mMaterials = new aiMaterial *[newMats.size()];
+    for (unsigned int i = 0; i < newMats.size(); ++i) {
+        pScene->mMaterials[i] = newMats[i].second;
+    }
+    newMats.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Stores all animations
+void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser) {
+    // recursively collect all animations from the collada scene
+    StoreAnimations(pScene, pParser, &pParser.mAnims, "");
+
+    // catch special case: many animations with the same length, each affecting only a single node.
+    // we need to unite all those single-node-anims to a proper combined animation
+    for (size_t a = 0; a < mAnims.size(); ++a) {
+        aiAnimation *templateAnim = mAnims[a];
+
+        if (templateAnim->mNumChannels == 1) {
+            // search for other single-channel-anims with the same duration
+            std::vector<size_t> collectedAnimIndices;
+            for (size_t b = a + 1; b < mAnims.size(); ++b) {
+                aiAnimation *other = mAnims[b];
+                if (other->mNumChannels == 1 && other->mDuration == templateAnim->mDuration &&
+                        other->mTicksPerSecond == templateAnim->mTicksPerSecond)
+                    collectedAnimIndices.push_back(b);
+            }
+
+            // We only want to combine the animations if they have different channels
+            std::set<std::string> animTargets;
+            animTargets.insert(templateAnim->mChannels[0]->mNodeName.C_Str());
+            bool collectedAnimationsHaveDifferentChannels = true;
+            for (unsigned long long collectedAnimIndice : collectedAnimIndices) {
+                aiAnimation *srcAnimation = mAnims[(int)collectedAnimIndice];
+                std::string channelName = std::string(srcAnimation->mChannels[0]->mNodeName.C_Str());
+                if (animTargets.find(channelName) == animTargets.end()) {
+                    animTargets.insert(channelName);
+                } else {
+                    collectedAnimationsHaveDifferentChannels = false;
+                    break;
+                }
+            }
+
+            if (!collectedAnimationsHaveDifferentChannels) {
+                continue;
+            }
+
+            // if there are other animations which fit the template anim, combine all channels into a single anim
+            if (!collectedAnimIndices.empty()) {
+                aiAnimation *combinedAnim = new aiAnimation();
+                combinedAnim->mName = aiString(std::string("combinedAnim_") + char('0' + a));
+                combinedAnim->mDuration = templateAnim->mDuration;
+                combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond;
+                combinedAnim->mNumChannels = static_cast<unsigned int>(collectedAnimIndices.size() + 1);
+                combinedAnim->mChannels = new aiNodeAnim *[combinedAnim->mNumChannels];
+                // add the template anim as first channel by moving its aiNodeAnim to the combined animation
+                combinedAnim->mChannels[0] = templateAnim->mChannels[0];
+                templateAnim->mChannels[0] = nullptr;
+                delete templateAnim;
+                // combined animation replaces template animation in the anim array
+                mAnims[a] = combinedAnim;
+
+                // move the memory of all other anims to the combined anim and erase them from the source anims
+                for (size_t b = 0; b < collectedAnimIndices.size(); ++b) {
+                    aiAnimation *srcAnimation = mAnims[collectedAnimIndices[b]];
+                    combinedAnim->mChannels[1 + b] = srcAnimation->mChannels[0];
+                    srcAnimation->mChannels[0] = nullptr;
+                    delete srcAnimation;
+                }
+
+                // in a second go, delete all the single-channel-anims that we've stripped from their channels
+                // back to front to preserve indices - you know, removing an element from a vector moves all elements behind the removed one
+                while (!collectedAnimIndices.empty()) {
+                    mAnims.erase(mAnims.begin() + collectedAnimIndices.back());
+                    collectedAnimIndices.pop_back();
+                }
+            }
+        }
+    }
+
+    // now store all anims in the scene
+    if (!mAnims.empty()) {
+        pScene->mNumAnimations = static_cast<unsigned int>(mAnims.size());
+        pScene->mAnimations = new aiAnimation *[mAnims.size()];
+        std::copy(mAnims.begin(), mAnims.end(), pScene->mAnimations);
+    }
+
+    mAnims.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructs the animations for the given source anim
+void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pPrefix) {
+    std::string animName = pPrefix.empty() ? pSrcAnim->mName : pPrefix + "_" + pSrcAnim->mName;
+
+    // create nested animations, if given
+    for (auto mSubAnim : pSrcAnim->mSubAnims) {
+        StoreAnimations(pScene, pParser, mSubAnim, animName);
+    }
+
+    // create animation channels, if any
+    if (!pSrcAnim->mChannels.empty()) {
+        CreateAnimation(pScene, pParser, pSrcAnim, animName);
+    }
+}
+
+struct MorphTimeValues {
+    float mTime;
+    struct key {
+        float mWeight;
+        unsigned int mValue;
+    };
+    std::vector<key> mKeys;
+};
+
+void insertMorphTimeValue(std::vector<MorphTimeValues> &values, float time, float weight, unsigned int value) {
+    MorphTimeValues::key k;
+    k.mValue = value;
+    k.mWeight = weight;
+    if (values.empty() || time < values[0].mTime) {
+        MorphTimeValues val;
+        val.mTime = time;
+        val.mKeys.push_back(k);
+        values.insert(values.begin(), val);
+        return;
+    }
+    if (time > values.back().mTime) {
+        MorphTimeValues val;
+        val.mTime = time;
+        val.mKeys.push_back(k);
+        values.insert(values.end(), val);
+        return;
+    }
+    for (unsigned int i = 0; i < values.size(); i++) {
+        if (std::abs(time - values[i].mTime) < ai_epsilon) {
+            values[i].mKeys.push_back(k);
+            return;
+        } else if (time > values[i].mTime && time < values[i + 1].mTime) {
+            MorphTimeValues val;
+            val.mTime = time;
+            val.mKeys.push_back(k);
+            values.insert(values.begin() + i, val);
+            return;
+        }
+    }
+}
+
+static float getWeightAtKey(const std::vector<MorphTimeValues> &values, int key, unsigned int value) {
+    for (auto mKey : values[key].mKeys) {
+        if (mKey.mValue == value) {
+            return mKey.mWeight;
+        }
+    }
+    // no value at key found, try to interpolate if present at other keys. if not, return zero
+    // TODO: interpolation
+    return 0.0f;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructs the animation for the given source anim
+void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pName) {
+    // collect a list of animatable nodes
+    std::vector<const aiNode *> nodes;
+    CollectNodes(pScene->mRootNode, nodes);
+
+    std::vector<aiNodeAnim *> anims;
+    std::vector<aiMeshMorphAnim *> morphAnims;
+
+    for (auto node : nodes) {
+        // find all the collada anim channels which refer to the current node
+        std::vector<ChannelEntry> entries;
+        std::string nodeName = node->mName.data;
+
+        // find the collada node corresponding to the aiNode
+        const Node *srcNode = FindNode(pParser.mRootNode, nodeName);
+        if (!srcNode) {
+            continue;
+        }
+
+        // now check all channels if they affect the current node
+        std::string targetID, subElement;
+        for (std::vector<AnimationChannel>::const_iterator cit = pSrcAnim->mChannels.begin();
+                cit != pSrcAnim->mChannels.end(); ++cit) {
+            const AnimationChannel &srcChannel = *cit;
+            ChannelEntry entry;
+
+            // we expect the animation target to be of type "nodeName/transformID.subElement". Ignore all others
+            // find the slash that separates the node name - there should be only one
+            std::string::size_type slashPos = srcChannel.mTarget.find('/');
+            if (slashPos == std::string::npos) {
+                std::string::size_type targetPos = srcChannel.mTarget.find(srcNode->mID);
+                if (targetPos == std::string::npos) {
+                    continue;
+                }
+
+                // not node transform, but something else. store as unknown animation channel for now
+                entry.mChannel = &(*cit);
+                entry.mTargetId = srcChannel.mTarget.substr(targetPos + pSrcAnim->mName.length(),
+                        srcChannel.mTarget.length() - targetPos - pSrcAnim->mName.length());
+                if (entry.mTargetId.front() == '-') {
+                    entry.mTargetId = entry.mTargetId.substr(1);
+                }
+                entries.push_back(entry);
+                continue;
+            }
+            if (srcChannel.mTarget.find('/', slashPos + 1) != std::string::npos) {
+                continue;
+            }
+
+            targetID.clear();
+            targetID = srcChannel.mTarget.substr(0, slashPos);
+            if (targetID != srcNode->mID) {
+                continue;
+            }
+
+            // find the dot that separates the transformID - there should be only one or zero
+            std::string::size_type dotPos = srcChannel.mTarget.find('.');
+            if (dotPos != std::string::npos) {
+                if (srcChannel.mTarget.find('.', dotPos + 1) != std::string::npos) {
+                    continue;
+                }
+
+                entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, dotPos - slashPos - 1);
+
+                subElement.clear();
+                subElement = srcChannel.mTarget.substr(dotPos + 1);
+                if (subElement == "ANGLE")
+                    entry.mSubElement = 3; // last number in an Axis-Angle-Transform is the angle
+                else if (subElement == "X")
+                    entry.mSubElement = 0;
+                else if (subElement == "Y")
+                    entry.mSubElement = 1;
+                else if (subElement == "Z")
+                    entry.mSubElement = 2;
+                else
+                    ASSIMP_LOG_WARN("Unknown anim subelement <", subElement, ">. Ignoring");
+            } else {
+                // no sub-element following, transformId is remaining string
+                entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1);
+            }
+
+            std::string::size_type bracketPos = srcChannel.mTarget.find('(');
+            if (bracketPos != std::string::npos) {
+                entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, bracketPos - slashPos - 1);
+                subElement.clear();
+                subElement = srcChannel.mTarget.substr(bracketPos);
+
+                if (subElement == "(0)(0)")
+                    entry.mSubElement = 0;
+                else if (subElement == "(1)(0)")
+                    entry.mSubElement = 1;
+                else if (subElement == "(2)(0)")
+                    entry.mSubElement = 2;
+                else if (subElement == "(3)(0)")
+                    entry.mSubElement = 3;
+                else if (subElement == "(0)(1)")
+                    entry.mSubElement = 4;
+                else if (subElement == "(1)(1)")
+                    entry.mSubElement = 5;
+                else if (subElement == "(2)(1)")
+                    entry.mSubElement = 6;
+                else if (subElement == "(3)(1)")
+                    entry.mSubElement = 7;
+                else if (subElement == "(0)(2)")
+                    entry.mSubElement = 8;
+                else if (subElement == "(1)(2)")
+                    entry.mSubElement = 9;
+                else if (subElement == "(2)(2)")
+                    entry.mSubElement = 10;
+                else if (subElement == "(3)(2)")
+                    entry.mSubElement = 11;
+                else if (subElement == "(0)(3)")
+                    entry.mSubElement = 12;
+                else if (subElement == "(1)(3)")
+                    entry.mSubElement = 13;
+                else if (subElement == "(2)(3)")
+                    entry.mSubElement = 14;
+                else if (subElement == "(3)(3)")
+                    entry.mSubElement = 15;
+            }
+
+            // determine which transform step is affected by this channel
+            entry.mTransformIndex = SIZE_MAX;
+            for (size_t a = 0; a < srcNode->mTransforms.size(); ++a)
+                if (srcNode->mTransforms[a].mID == entry.mTransformId)
+                    entry.mTransformIndex = a;
+
+            if (entry.mTransformIndex == SIZE_MAX) {
+                if (entry.mTransformId.find("morph-weights") == std::string::npos) {
+                    continue;
+                }
+                entry.mTargetId = entry.mTransformId;
+                entry.mTransformId = std::string();
+            }
+
+            entry.mChannel = &(*cit);
+            entries.push_back(entry);
+        }
+
+        // if there's no channel affecting the current node, we skip it
+        if (entries.empty()) {
+            continue;
+        }
+
+        // resolve the data pointers for all anim channels. Find the minimum time while we're at it
+        ai_real startTime = ai_real(1e20), endTime = ai_real(-1e20);
+        for (ChannelEntry & e : entries) {
+            e.mTimeAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceTimes);
+            e.mTimeData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mTimeAccessor->mSource);
+            e.mValueAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceValues);
+            e.mValueData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mValueAccessor->mSource);
+
+            // time count and value count must match
+            if (e.mTimeAccessor->mCount != e.mValueAccessor->mCount) {
+                throw DeadlyImportError("Time count / value count mismatch in animation channel \"", e.mChannel->mTarget, "\".");
+            }
+
+            if (e.mTimeAccessor->mCount > 0) {
+                // find bounding times
+                startTime = std::min(startTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, 0, 0));
+                endTime = std::max(endTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, e.mTimeAccessor->mCount - 1, 0));
+            }
+        }
+
+        std::vector<aiMatrix4x4> resultTrafos;
+        if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) {
+            // create a local transformation chain of the node's transforms
+            std::vector<Collada::Transform> transforms = srcNode->mTransforms;
+
+            // now for every unique point in time, find or interpolate the key values for that time
+            // and apply them to the transform chain. Then the node's present transformation can be calculated.
+            ai_real time = startTime;
+            while (1) {
+                for (ChannelEntry & e : entries) {
+                    // find the keyframe behind the current point in time
+                    size_t pos = 0;
+                    ai_real postTime = 0.0;
+                    while (1) {
+                        if (pos >= e.mTimeAccessor->mCount) {
+                            break;
+                        }
+                        postTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos, 0);
+                        if (postTime >= time) {
+                            break;
+                        }
+                        ++pos;
+                    }
+
+                    pos = std::min(pos, e.mTimeAccessor->mCount - 1);
+
+                    // read values from there
+                    ai_real temp[16];
+                    for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) {
+                        temp[c] = ReadFloat(*e.mValueAccessor, *e.mValueData, pos, c);
+                    }
+
+                    // if not exactly at the key time, interpolate with previous value set
+                    if (postTime > time && pos > 0) {
+                        ai_real preTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos - 1, 0);
+                        ai_real factor = (time - postTime) / (preTime - postTime);
+
+                        for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) {
+                            ai_real v = ReadFloat(*e.mValueAccessor, *e.mValueData, pos - 1, c);
+                            temp[c] += (v - temp[c]) * factor;
+                        }
+                    }
+
+                    // Apply values to current transformation
+                    std::copy(temp, temp + e.mValueAccessor->mSize, transforms[e.mTransformIndex].f + e.mSubElement);
+                }
+
+                // Calculate resulting transformation
+                aiMatrix4x4 mat = pParser.CalculateResultTransform(transforms);
+
+                // out of laziness: we store the time in matrix.d4
+                mat.d4 = time;
+                resultTrafos.push_back(mat);
+
+                // find next point in time to evaluate. That's the closest frame larger than the current in any channel
+                ai_real nextTime = ai_real(1e20);
+                for (ChannelEntry & channelElement : entries) {
+                    // find the next time value larger than the current
+                    size_t pos = 0;
+                    while (pos < channelElement.mTimeAccessor->mCount) {
+                        const ai_real t = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
+                        if (t > time) {
+                            nextTime = std::min(nextTime, t);
+                            break;
+                        }
+                        ++pos;
+                    }
+
+                    // https://github.com/assimp/assimp/issues/458
+                    // Sub-sample axis-angle channels if the delta between two consecutive
+                    // key-frame angles is >= 180 degrees.
+                    if (transforms[channelElement.mTransformIndex].mType == TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) {
+                        const ai_real cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0);
+                        const ai_real last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0);
+                        const ai_real cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
+                        const ai_real last_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos - 1, 0);
+                        const ai_real last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time);
+                        const ai_real delta = std::abs(cur_key_angle - last_eval_angle);
+                        if (delta >= 180.0) {
+                            const int subSampleCount = static_cast<int>(std::floor(delta / 90.0));
+                            if (cur_key_time != time) {
+                                const ai_real nextSampleTime = time + (cur_key_time - time) / subSampleCount;
+                                nextTime = std::min(nextTime, nextSampleTime);
+                            }
+                        }
+                    }
+                }
+
+                // no more keys on any channel after the current time -> we're done
+                if (nextTime > 1e19) {
+                    break;
+                }
+
+                // else construct next key-frame at this following time point
+                time = nextTime;
+            }
+        }
+
+        // build an animation channel for the given node out of these trafo keys
+        if (!resultTrafos.empty()) {
+            aiNodeAnim *dstAnim = new aiNodeAnim;
+            dstAnim->mNodeName = nodeName;
+            dstAnim->mNumPositionKeys = static_cast<unsigned int>(resultTrafos.size());
+            dstAnim->mNumRotationKeys = static_cast<unsigned int>(resultTrafos.size());
+            dstAnim->mNumScalingKeys = static_cast<unsigned int>(resultTrafos.size());
+            dstAnim->mPositionKeys = new aiVectorKey[resultTrafos.size()];
+            dstAnim->mRotationKeys = new aiQuatKey[resultTrafos.size()];
+            dstAnim->mScalingKeys = new aiVectorKey[resultTrafos.size()];
+
+            for (size_t a = 0; a < resultTrafos.size(); ++a) {
+                aiMatrix4x4 mat = resultTrafos[a];
+                double time = double(mat.d4); // remember? time is stored in mat.d4
+                mat.d4 = 1.0f;
+
+                dstAnim->mPositionKeys[a].mTime = time * kMillisecondsFromSeconds;
+                dstAnim->mRotationKeys[a].mTime = time * kMillisecondsFromSeconds;
+                dstAnim->mScalingKeys[a].mTime = time * kMillisecondsFromSeconds;
+                mat.Decompose(dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue);
+            }
+
+            anims.push_back(dstAnim);
+        } else {
+            ASSIMP_LOG_WARN("Collada loader: found empty animation channel, ignored. Please check your exporter.");
+        }
+
+        if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) {
+            std::vector<ChannelEntry> morphChannels;
+            for (ChannelEntry & e : entries) {
+                // skip non-transform types
+                if (e.mTargetId.empty()) {
+                    continue;
+                }
+
+                if (e.mTargetId.find("morph-weights") != std::string::npos) {
+                    morphChannels.push_back(e);
+                }
+            }
+            if (!morphChannels.empty()) {
+                // either 1) morph weight animation count should contain morph target count channels
+                // or     2) one channel with morph target count arrays
+                // assume first
+
+                aiMeshMorphAnim *morphAnim = new aiMeshMorphAnim;
+                morphAnim->mName.Set(nodeName);
+
+                std::vector<MorphTimeValues> morphTimeValues;
+                int morphAnimChannelIndex = 0;
+                for (ChannelEntry & e : morphChannels) {
+                    std::string::size_type apos = e.mTargetId.find('(');
+                    std::string::size_type bpos = e.mTargetId.find(')');
+
+                    // If unknown way to specify weight -> ignore this animation
+                    if (apos == std::string::npos || bpos == std::string::npos) {
+                        continue;
+                    }
+
+                    // weight target can be in format Weight_M_N, Weight_N, WeightN, or some other way
+                    // we ignore the name and just assume the channels are in the right order
+                    for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++) {
+                        insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues[i], e.mValueData->mValues[i], morphAnimChannelIndex);
+                    }
+
+                    ++morphAnimChannelIndex;
+                }
+
+                morphAnim->mNumKeys = static_cast<unsigned int>(morphTimeValues.size());
+                morphAnim->mKeys = new aiMeshMorphKey[morphAnim->mNumKeys];
+                for (unsigned int key = 0; key < morphAnim->mNumKeys; key++) {
+                    morphAnim->mKeys[key].mNumValuesAndWeights = static_cast<unsigned int>(morphChannels.size());
+                    morphAnim->mKeys[key].mValues = new unsigned int[morphChannels.size()];
+                    morphAnim->mKeys[key].mWeights = new double[morphChannels.size()];
+
+                    morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime * kMillisecondsFromSeconds;
+                    for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); ++valueIndex) {
+                        morphAnim->mKeys[key].mValues[valueIndex] = valueIndex;
+                        morphAnim->mKeys[key].mWeights[valueIndex] = getWeightAtKey(morphTimeValues, key, valueIndex);
+                    }
+                }
+
+                morphAnims.push_back(morphAnim);
+            }
+        }
+    }
+
+    if (!anims.empty() || !morphAnims.empty()) {
+        aiAnimation *anim = new aiAnimation;
+        anim->mName.Set(pName);
+        anim->mNumChannels = static_cast<unsigned int>(anims.size());
+        if (anim->mNumChannels > 0) {
+            anim->mChannels = new aiNodeAnim *[anims.size()];
+            std::copy(anims.begin(), anims.end(), anim->mChannels);
+        }
+        anim->mNumMorphMeshChannels = static_cast<unsigned int>(morphAnims.size());
+        if (anim->mNumMorphMeshChannels > 0) {
+            anim->mMorphMeshChannels = new aiMeshMorphAnim *[anim->mNumMorphMeshChannels];
+            std::copy(morphAnims.begin(), morphAnims.end(), anim->mMorphMeshChannels);
+        }
+        anim->mDuration = 0.0f;
+        for (auto & a : anims) {
+            anim->mDuration = std::max(anim->mDuration, a->mPositionKeys[a->mNumPositionKeys - 1].mTime);
+            anim->mDuration = std::max(anim->mDuration, a->mRotationKeys[a->mNumRotationKeys - 1].mTime);
+            anim->mDuration = std::max(anim->mDuration, a->mScalingKeys[a->mNumScalingKeys - 1].mTime);
+        }
+        for (auto & morphAnim : morphAnims) {
+            anim->mDuration = std::max(anim->mDuration, morphAnim->mKeys[morphAnim->mNumKeys - 1].mTime);
+        }
+        anim->mTicksPerSecond = 1000.0;
+        mAnims.push_back(anim);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add a texture to a material structure
+void ColladaLoader::AddTexture(aiMaterial &mat,
+        const ColladaParser &pParser,
+        const Effect &effect,
+        const Sampler &sampler,
+        aiTextureType type,
+        unsigned int idx) {
+    // first of all, basic file name
+    const aiString name = FindFilenameForEffectTexture(pParser, effect, sampler.mName);
+    mat.AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, type, idx);
+
+    // mapping mode
+    int map = aiTextureMapMode_Clamp;
+    if (sampler.mWrapU) {
+        map = aiTextureMapMode_Wrap;
+    }
+    if (sampler.mWrapU && sampler.mMirrorU) {
+        map = aiTextureMapMode_Mirror;
+    }
+
+    mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_U_BASE, type, idx);
+
+    map = aiTextureMapMode_Clamp;
+    if (sampler.mWrapV) {
+        map = aiTextureMapMode_Wrap;
+    }
+    if (sampler.mWrapV && sampler.mMirrorV) {
+        map = aiTextureMapMode_Mirror;
+    }
+
+    mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_V_BASE, type, idx);
+
+    // UV transformation
+    mat.AddProperty(&sampler.mTransform, 1,
+            _AI_MATKEY_UVTRANSFORM_BASE, type, idx);
+
+    // Blend mode
+    mat.AddProperty((int *)&sampler.mOp, 1,
+            _AI_MATKEY_TEXBLEND_BASE, type, idx);
+
+    // Blend factor
+    mat.AddProperty((ai_real *)&sampler.mWeighting, 1,
+            _AI_MATKEY_TEXBLEND_BASE, type, idx);
+
+    // UV source index ... if we didn't resolve the mapping, it is actually just
+    // a guess but it works in most cases. We search for the frst occurrence of a
+    // number in the channel name. We assume it is the zero-based index into the
+    // UV channel array of all corresponding meshes. It could also be one-based
+    // for some exporters, but we won't care of it unless someone complains about.
+    if (sampler.mUVId != UINT_MAX) {
+        map = sampler.mUVId;
+    } else {
+        map = -1;
+        for (std::string::const_iterator it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) {
+            if (IsNumeric(*it)) {
+                map = strtoul10(&(*it));        
+                break;
+            }
+        }
+        if (-1 == map) {
+            ASSIMP_LOG_WARN("Collada: unable to determine UV channel for texture");
+            map = 0;
+        }
+    }
+    mat.AddProperty(&map, 1, _AI_MATKEY_UVWSRC_BASE, type, idx);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Fills materials from the collada material definitions
+void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pScene*/) {
+    for (auto &elem : newMats) {
+        aiMaterial &mat = (aiMaterial &)*elem.second;
+        Collada::Effect &effect = *elem.first;
+
+        // resolve shading mode
+        int shadeMode;
+        if (effect.mFaceted) {
+            shadeMode = aiShadingMode_Flat;
+        } else {
+            switch (effect.mShadeType) {
+            case Collada::Shade_Constant:
+                shadeMode = aiShadingMode_NoShading;
+                break;
+            case Collada::Shade_Lambert:
+                shadeMode = aiShadingMode_Gouraud;
+                break;
+            case Collada::Shade_Blinn:
+                shadeMode = aiShadingMode_Blinn;
+                break;
+            case Collada::Shade_Phong:
+                shadeMode = aiShadingMode_Phong;
+                break;
+
+            default:
+                ASSIMP_LOG_WARN("Collada: Unrecognized shading mode, using gouraud shading");
+                shadeMode = aiShadingMode_Gouraud;
+                break;
+            }
+        }
+        mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
+
+        // double-sided?
+        shadeMode = effect.mDoubleSided;
+        mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_TWOSIDED);
+
+        // wire-frame?
+        shadeMode = effect.mWireframe;
+        mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_ENABLE_WIREFRAME);
+
+        // add material colors
+        mat.AddProperty(&effect.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
+        mat.AddProperty(&effect.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+        mat.AddProperty(&effect.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
+        mat.AddProperty(&effect.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+        mat.AddProperty(&effect.mReflective, 1, AI_MATKEY_COLOR_REFLECTIVE);
+
+        // scalar properties
+        mat.AddProperty(&effect.mShininess, 1, AI_MATKEY_SHININESS);
+        mat.AddProperty(&effect.mReflectivity, 1, AI_MATKEY_REFLECTIVITY);
+        mat.AddProperty(&effect.mRefractIndex, 1, AI_MATKEY_REFRACTI);
+
+        // transparency, a very hard one. seemingly not all files are following the
+        // specification here (1.0 transparency => completely opaque)...
+        // therefore, we let the opportunity for the user to manually invert
+        // the transparency if necessary and we add preliminary support for RGB_ZERO mode
+        if (effect.mTransparency >= 0.f && effect.mTransparency <= 1.f) {
+            // handle RGB transparency completely, cf Collada specs 1.5.0 pages 249 and 304
+            if (effect.mRGBTransparency) {
+                // use luminance as defined by ISO/CIE color standards (see ITU-R Recommendation BT.709-4)
+                effect.mTransparency *= (0.212671f * effect.mTransparent.r +
+                                         0.715160f * effect.mTransparent.g +
+                                         0.072169f * effect.mTransparent.b);
+
+                effect.mTransparent.a = 1.f;
+
+                mat.AddProperty(&effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT);
+            } else {
+                effect.mTransparency *= effect.mTransparent.a;
+            }
+
+            if (effect.mInvertTransparency) {
+                effect.mTransparency = 1.f - effect.mTransparency;
+            }
+
+            // Is the material finally transparent ?
+            if (effect.mHasTransparency || effect.mTransparency < 1.f) {
+                mat.AddProperty(&effect.mTransparency, 1, AI_MATKEY_OPACITY);
+            }
+        }
+
+        // add textures, if given
+        if (!effect.mTexAmbient.mName.empty()) {
+            // It is merely a light-map
+            AddTexture(mat, pParser, effect, effect.mTexAmbient, aiTextureType_LIGHTMAP);
+        }
+
+        if (!effect.mTexEmissive.mName.empty())
+            AddTexture(mat, pParser, effect, effect.mTexEmissive, aiTextureType_EMISSIVE);
+
+        if (!effect.mTexSpecular.mName.empty())
+            AddTexture(mat, pParser, effect, effect.mTexSpecular, aiTextureType_SPECULAR);
+
+        if (!effect.mTexDiffuse.mName.empty())
+            AddTexture(mat, pParser, effect, effect.mTexDiffuse, aiTextureType_DIFFUSE);
+
+        if (!effect.mTexBump.mName.empty())
+            AddTexture(mat, pParser, effect, effect.mTexBump, aiTextureType_NORMALS);
+
+        if (!effect.mTexTransparent.mName.empty())
+            AddTexture(mat, pParser, effect, effect.mTexTransparent, aiTextureType_OPACITY);
+
+        if (!effect.mTexReflective.mName.empty())
+            AddTexture(mat, pParser, effect, effect.mTexReflective, aiTextureType_REFLECTION);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructs materials from the collada material definitions
+void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/) {
+    newMats.reserve(pParser.mMaterialLibrary.size());
+
+    for (ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin();
+            matIt != pParser.mMaterialLibrary.end(); ++matIt) {
+        const Material &material = matIt->second;
+        // a material is only a reference to an effect
+        ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect);
+        if (effIt == pParser.mEffectLibrary.end())
+            continue;
+        Effect &effect = effIt->second;
+
+        // create material
+        aiMaterial *mat = new aiMaterial;
+        aiString name(material.mName.empty() ? matIt->first : material.mName);
+        mat->AddProperty(&name, AI_MATKEY_NAME);
+
+        // store the material
+        mMaterialIndexByName[matIt->first] = newMats.size();
+        newMats.emplace_back(&effect, mat);
+    }
+    // ScenePreprocessor generates a default material automatically if none is there.
+    // All further code here in this loader works well without a valid material so
+    // we can safely let it to ScenePreprocessor.
+}
+
+// ------------------------------------------------------------------------------------------------
+// Resolves the texture name for the given effect texture entry and loads the texture data
+aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParser,
+        const Effect &pEffect, const std::string &pName) {
+    aiString result;
+
+    // recurse through the param references until we end up at an image
+    std::string name = pName;
+    while (1) {
+        // the given string is a param entry. Find it
+        Effect::ParamLibrary::const_iterator it = pEffect.mParams.find(name);
+        // if not found, we're at the end of the recursion. The resulting string should be the image ID
+        if (it == pEffect.mParams.end())
+            break;
+
+        // else recurse on
+        name = it->second.mReference;
+    }
+
+    // find the image referred by this name in the image library of the scene
+    ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find(name);
+    if (imIt == pParser.mImageLibrary.end()) {
+        ASSIMP_LOG_WARN("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\".");
+
+        //set default texture file name
+        result.Set(name + ".jpg");
+        ColladaParser::UriDecodePath(result);
+        return result;
+    }
+
+    // if this is an embedded texture image setup an aiTexture for it
+    if (!imIt->second.mImageData.empty()) {
+        aiTexture *tex = new aiTexture();
+
+        // Store embedded texture name reference
+        tex->mFilename.Set(imIt->second.mFileName.c_str());
+        result.Set(imIt->second.mFileName);
+
+        // setup format hint
+        if (imIt->second.mEmbeddedFormat.length() >= HINTMAXTEXTURELEN) {
+            ASSIMP_LOG_WARN("Collada: texture format hint is too long, truncating to 3 characters");
+        }
+        strncpy(tex->achFormatHint, imIt->second.mEmbeddedFormat.c_str(), 3);
+
+        // and copy texture data
+        tex->mHeight = 0;
+        tex->mWidth = static_cast<unsigned int>(imIt->second.mImageData.size());
+        tex->pcData = (aiTexel *)new char[tex->mWidth];
+        memcpy(tex->pcData, &imIt->second.mImageData[0], tex->mWidth);
+
+        // and add this texture to the list
+        mTextures.push_back(tex);
+        return result;
+    }
+
+    if (imIt->second.mFileName.empty()) {
+        throw DeadlyImportError("Collada: Invalid texture, no data or file reference given");
+    }
+
+    result.Set(imIt->second.mFileName);
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a float value from an accessor and its data array.
+ai_real ColladaLoader::ReadFloat(const Accessor &pAccessor, const Data &pData, size_t pIndex, size_t pOffset) const {
+    size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset;
+    ai_assert(pos < pData.mValues.size());
+    return pData.mValues[pos];
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a string value from an accessor and its data array.
+const std::string &ColladaLoader::ReadString(const Accessor &pAccessor, const Data &pData, size_t pIndex) const {
+    size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset;
+    ai_assert(pos < pData.mStrings.size());
+    return pData.mStrings[pos];
+}
+
+// ------------------------------------------------------------------------------------------------
+// Collects all nodes into the given array
+void ColladaLoader::CollectNodes(const aiNode *pNode, std::vector<const aiNode *> &poNodes) const {
+    poNodes.push_back(pNode);
+    for (size_t a = 0; a < pNode->mNumChildren; ++a) {
+        CollectNodes(pNode->mChildren[a], poNodes);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Finds a node in the collada scene by the given name
+const Node *ColladaLoader::FindNode(const Node *pNode, const std::string &pName) const {
+    if (pNode->mName == pName || pNode->mID == pName)
+        return pNode;
+
+    for (auto a : pNode->mChildren) {
+        const Collada::Node *node = FindNode(a, pName);
+        if (node) {
+            return node;
+        }
+    }
+
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Finds a node in the collada scene by the given SID
+const Node *ColladaLoader::FindNodeBySID(const Node *pNode, const std::string &pSID) const {
+    if (nullptr == pNode) {
+        return nullptr;
+    }
+
+    if (pNode->mSID == pSID) {
+        return pNode;
+    }
+
+    for (auto a : pNode->mChildren) {
+        const Collada::Node *node = FindNodeBySID(a, pSID);
+        if (node) {
+            return node;
+        }
+    }
+
+    return nullptr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Finds a proper unique name for a node derived from the collada-node's properties.
+// The name must be unique for proper node-bone association.
+std::string ColladaLoader::FindNameForNode(const Node *pNode) {
+    // If explicitly requested, just use the collada name.
+    if (useColladaName) {
+        if (!pNode->mName.empty()) {
+            return pNode->mName;
+        } else {
+            return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
+        }
+    } else {
+        // Now setup the name of the assimp node. The collada name might not be
+        // unique, so we use the collada ID.
+        if (!pNode->mID.empty())
+            return pNode->mID;
+        else if (!pNode->mSID.empty())
+            return pNode->mSID;
+        else {
+            // No need to worry. Unnamed nodes are no problem at all, except
+            // if cameras or lights need to be assigned to them.
+            return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
+        }
+    }
+}
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h
new file mode 100644
index 0000000..246abed
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h
@@ -0,0 +1,249 @@
+/** Defines the collada loader class */
+
+/*
+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.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef AI_COLLADALOADER_H_INC
+#define AI_COLLADALOADER_H_INC
+
+#include "ColladaParser.h"
+#include <assimp/BaseImporter.h>
+
+struct aiNode;
+struct aiCamera;
+struct aiLight;
+struct aiTexture;
+struct aiAnimation;
+
+namespace Assimp {
+
+struct ColladaMeshIndex {
+    std::string mMeshID;
+    size_t mSubMesh;
+    std::string mMaterial;
+    ColladaMeshIndex(const std::string &pMeshID, size_t pSubMesh, const std::string &pMaterial) :
+            mMeshID(pMeshID), mSubMesh(pSubMesh), mMaterial(pMaterial) {
+        ai_assert(!pMeshID.empty());
+    }
+
+    bool operator<(const ColladaMeshIndex &p) const {
+        if (mMeshID == p.mMeshID) {
+            if (mSubMesh == p.mSubMesh)
+                return mMaterial < p.mMaterial;
+            else
+                return mSubMesh < p.mSubMesh;
+        } else {
+            return mMeshID < p.mMeshID;
+        }
+    }
+};
+
+/** Loader class to read Collada scenes. Collada is over-engineered to death, with every new iteration bringing
+ * more useless stuff, so I limited the data to what I think is useful for games.
+*/
+class ColladaLoader : public BaseImporter {
+public:
+    /// The class constructor.
+    ColladaLoader();
+
+    /// The class destructor.
+    ~ColladaLoader() override;
+
+    /// Returns whether the class can handle the format of the given file.
+    /// @see BaseImporter::CanRead() for more details.
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override;
+
+protected:
+    /// See #BaseImporter::GetInfo for the details
+    const aiImporterDesc *GetInfo() const override;
+
+    /// See #BaseImporter::SetupProperties for the details
+    void SetupProperties(const Importer *pImp) override;
+
+    /// See #BaseImporter::InternReadFile for the details
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override;
+
+    /** Recursively constructs a scene node for the given parser node and returns it. */
+    aiNode *BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode);
+
+    /** Resolve node instances */
+    void ResolveNodeInstances(const ColladaParser &pParser, const Collada::Node *pNode,
+            std::vector<const Collada::Node *> &resolved);
+
+    /** Builds meshes for the given node and references them */
+    void BuildMeshesForNode(const ColladaParser &pParser, const Collada::Node *pNode,
+            aiNode *pTarget);
+
+    aiMesh *findMesh(const std::string &meshid);
+
+    /** Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh */
+    aiMesh *CreateMesh(const ColladaParser &pParser, const Collada::Mesh *pSrcMesh, const Collada::SubMesh &pSubMesh,
+            const Collada::Controller *pSrcController, size_t pStartVertex, size_t pStartFace);
+
+    /** Builds cameras for the given node and references them */
+    void BuildCamerasForNode(const ColladaParser &pParser, const Collada::Node *pNode,
+            aiNode *pTarget);
+
+    /** Builds lights for the given node and references them */
+    void BuildLightsForNode(const ColladaParser &pParser, const Collada::Node *pNode,
+            aiNode *pTarget);
+
+    /** Stores all meshes in the given scene */
+    void StoreSceneMeshes(aiScene *pScene);
+
+    /** Stores all materials in the given scene */
+    void StoreSceneMaterials(aiScene *pScene);
+
+    /** Stores all lights in the given scene */
+    void StoreSceneLights(aiScene *pScene);
+
+    /** Stores all cameras in the given scene */
+    void StoreSceneCameras(aiScene *pScene);
+
+    /** Stores all textures in the given scene */
+    void StoreSceneTextures(aiScene *pScene);
+
+    /** Stores all animations
+     * @param pScene target scene to store the anims
+     */
+    void StoreAnimations(aiScene *pScene, const ColladaParser &pParser);
+
+    /** Stores all animations for the given source anim and its nested child animations
+     * @param pScene target scene to store the anims
+     * @param pSrcAnim the source animation to process
+     * @param pPrefix Prefix to the name in case of nested animations
+     */
+    void StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Collada::Animation *pSrcAnim, const std::string &pPrefix);
+
+    /** Constructs the animation for the given source anim */
+    void CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Collada::Animation *pSrcAnim, const std::string &pName);
+
+    /** Constructs materials from the collada material definitions */
+    void BuildMaterials(ColladaParser &pParser, aiScene *pScene);
+
+    /** Fill materials from the collada material definitions */
+    void FillMaterials(const ColladaParser &pParser, aiScene *pScene);
+
+    /** Resolve UV channel mappings*/
+    void ApplyVertexToEffectSemanticMapping(Collada::Sampler &sampler,
+            const Collada::SemanticMappingTable &table);
+
+    /** Add a texture and all of its sampling properties to a material*/
+    void AddTexture(aiMaterial &mat, const ColladaParser &pParser,
+            const Collada::Effect &effect,
+            const Collada::Sampler &sampler,
+            aiTextureType type, unsigned int idx = 0);
+
+    /** Resolves the texture name for the given effect texture entry */
+    aiString FindFilenameForEffectTexture(const ColladaParser &pParser,
+            const Collada::Effect &pEffect, const std::string &pName);
+
+    /** Reads a float value from an accessor and its data array.
+     * @param pAccessor The accessor to use for reading
+     * @param pData The data array to read from
+     * @param pIndex The index of the element to retrieve
+     * @param pOffset Offset into the element, for multipart elements such as vectors or matrices
+     * @return the specified value
+     */
+    ai_real ReadFloat(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex, size_t pOffset) const;
+
+    /** Reads a string value from an accessor and its data array.
+     * @param pAccessor The accessor to use for reading
+     * @param pData The data array to read from
+     * @param pIndex The index of the element to retrieve
+     * @return the specified value
+     */
+    const std::string &ReadString(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex) const;
+
+    /** Recursively collects all nodes into the given array */
+    void CollectNodes(const aiNode *pNode, std::vector<const aiNode *> &poNodes) const;
+
+    /** Finds a node in the collada scene by the given name */
+    const Collada::Node *FindNode(const Collada::Node *pNode, const std::string &pName) const;
+    /** Finds a node in the collada scene by the given SID */
+    const Collada::Node *FindNodeBySID(const Collada::Node *pNode, const std::string &pSID) const;
+
+    /** Finds a proper name for a node derived from the collada-node's properties */
+    std::string FindNameForNode(const Collada::Node *pNode);
+
+protected:
+    /** Filename, for a verbose error message */
+    std::string mFileName;
+
+    /** Which mesh-material compound was stored under which mesh ID */
+    std::map<ColladaMeshIndex, size_t> mMeshIndexByID;
+
+    /** Which material was stored under which index in the scene */
+    std::map<std::string, size_t> mMaterialIndexByName;
+
+    /** Accumulated meshes for the target scene */
+    std::vector<aiMesh *> mMeshes;
+
+    /** Accumulated morph target meshes */
+    std::vector<aiMesh *> mTargetMeshes;
+
+    /** Temporary material list */
+    std::vector<std::pair<Collada::Effect *, aiMaterial *>> newMats;
+
+    /** Temporary camera list */
+    std::vector<aiCamera *> mCameras;
+
+    /** Temporary light list */
+    std::vector<aiLight *> mLights;
+
+    /** Temporary texture list */
+    std::vector<aiTexture *> mTextures;
+
+    /** Accumulated animations for the target scene */
+    std::vector<aiAnimation *> mAnims;
+
+    bool noSkeletonMesh;
+    bool ignoreUpDirection;
+    bool useColladaName;
+
+    /** Used by FindNameForNode() to generate unique node names */
+    unsigned int mNodeNameCounter;
+};
+
+} // end of namespace Assimp
+
+#endif // AI_COLLADALOADER_H_INC
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp
new file mode 100644
index 0000000..922d1f6
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp
@@ -0,0 +1,2402 @@
+/*
+---------------------------------------------------------------------------
+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 ColladaParser.cpp
+ *  @brief Implementation of the Collada parser helper
+ */
+
+#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
+
+#include "ColladaParser.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/StringUtils.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/light.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <memory>
+
+using namespace Assimp;
+using namespace Assimp::Collada;
+using namespace Assimp::Formatter;
+
+static void ReportWarning(const char *msg, ...) {
+    ai_assert(nullptr != msg);
+
+    va_list args;
+    va_start(args, msg);
+
+    char szBuffer[3000];
+    const int iLen = vsprintf(szBuffer, msg, args);
+    ai_assert(iLen > 0);
+
+    va_end(args);
+    ASSIMP_LOG_WARN("Validation warning: ", std::string(szBuffer, iLen));
+}
+
+static bool FindCommonKey(const std::string &collada_key, const MetaKeyPairVector &key_renaming, size_t &found_index) {
+    for (size_t i = 0; i < key_renaming.size(); ++i) {
+        if (key_renaming[i].first == collada_key) {
+            found_index = i;
+            return true;
+        }
+    }
+    found_index = std::numeric_limits<size_t>::max();
+
+    return false;
+}
+
+static void readUrlAttribute(XmlNode &node, std::string &url) {
+    url.clear();
+    if (!XmlParser::getStdStrAttribute(node, "url", url)) {
+        return;
+    }
+    if (url[0] != '#') {
+        throw DeadlyImportError("Unknown reference format");
+    }
+    url = url.c_str() + 1;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+ColladaParser::ColladaParser(IOSystem *pIOHandler, const std::string &pFile) :
+        mFileName(pFile),
+        mXmlParser(),
+        mDataLibrary(),
+        mAccessorLibrary(),
+        mMeshLibrary(),
+        mNodeLibrary(),
+        mImageLibrary(),
+        mEffectLibrary(),
+        mMaterialLibrary(),
+        mLightLibrary(),
+        mCameraLibrary(),
+        mControllerLibrary(),
+        mRootNode(nullptr),
+        mAnims(),
+        mUnitSize(1.0f),
+        mUpDirection(UP_Y),
+        mFormat(FV_1_5_n) {
+    if (nullptr == pIOHandler) {
+        throw DeadlyImportError("IOSystem is nullptr.");
+    }
+
+    std::unique_ptr<IOStream> daefile;
+    std::unique_ptr<ZipArchiveIOSystem> zip_archive;
+
+    // Determine type
+    std::string extension = BaseImporter::GetExtension(pFile);
+    if (extension != "dae") {
+        zip_archive.reset(new ZipArchiveIOSystem(pIOHandler, pFile));
+    }
+
+    if (zip_archive && zip_archive->isOpen()) {
+        std::string dae_filename = ReadZaeManifest(*zip_archive);
+
+        if (dae_filename.empty()) {
+            throw DeadlyImportError("Invalid ZAE");
+        }
+
+        daefile.reset(zip_archive->Open(dae_filename.c_str()));
+        if (daefile == nullptr) {
+            throw DeadlyImportError("Invalid ZAE manifest: '", dae_filename, "' is missing");
+        }
+    } else {
+        // attempt to open the file directly
+        daefile.reset(pIOHandler->Open(pFile));
+        if (daefile.get() == nullptr) {
+            throw DeadlyImportError("Failed to open file '", pFile, "'.");
+        }
+    }
+
+    // generate a XML reader for it
+    if (!mXmlParser.parse(daefile.get())) {
+        throw DeadlyImportError("Unable to read file, malformed XML");
+    }
+    // start reading
+    XmlNode node = mXmlParser.getRootNode();
+    XmlNode colladaNode = node.child("COLLADA");
+    if (colladaNode.empty()) {
+        return;
+    }
+
+    // Read content and embedded textures
+    ReadContents(colladaNode);
+    if (zip_archive && zip_archive->isOpen()) {
+        ReadEmbeddedTextures(*zip_archive);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+ColladaParser::~ColladaParser() {
+    for (auto &it : mNodeLibrary) {
+        delete it.second;
+    }
+    for (auto &it : mMeshLibrary) {
+        delete it.second;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read a ZAE manifest and return the filename to attempt to open
+std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) {
+    // Open the manifest
+    std::unique_ptr<IOStream> manifestfile(zip_archive.Open("manifest.xml"));
+    if (manifestfile == nullptr) {
+        // No manifest, hope there is only one .DAE inside
+        std::vector<std::string> file_list;
+        zip_archive.getFileListExtension(file_list, "dae");
+
+        if (file_list.empty()) {
+            return std::string();
+        }
+
+        return file_list.front();
+    }
+    XmlParser manifestParser;
+    if (!manifestParser.parse(manifestfile.get())) {
+        return std::string();
+    }
+
+    XmlNode root = manifestParser.getRootNode();
+    const std::string &name = root.name();
+    if (name != "dae_root") {
+        root = *manifestParser.findNode("dae_root");
+        if (nullptr == root) {
+            return std::string();
+        }
+        std::string v;
+        XmlParser::getValueAsString(root, v);
+        aiString ai_str(v);
+        UriDecodePath(ai_str);
+        return std::string(ai_str.C_Str());
+    }
+
+    return std::string();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert a path read from a collada file to the usual representation
+void ColladaParser::UriDecodePath(aiString &ss) {
+    // TODO: collada spec, p 22. Handle URI correctly.
+    // For the moment we're just stripping the file:// away to make it work.
+    // Windows doesn't seem to be able to find stuff like
+    // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
+    if (0 == strncmp(ss.data, "file://", 7)) {
+        ss.length -= 7;
+        memmove(ss.data, ss.data + 7, ss.length);
+        ss.data[ss.length] = '\0';
+    }
+
+    // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes...
+    // I need to filter it without destroying linux paths starting with "/somewhere"
+    if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') {
+        --ss.length;
+        ::memmove(ss.data, ss.data + 1, ss.length);
+        ss.data[ss.length] = 0;
+    }
+
+    // find and convert all %xy special chars
+    char *out = ss.data;
+    for (const char *it = ss.data; it != ss.data + ss.length; /**/) {
+        if (*it == '%' && (it + 3) < ss.data + ss.length) {
+            // separate the number to avoid dragging in chars from behind into the parsing
+            char mychar[3] = { it[1], it[2], 0 };
+            size_t nbr = strtoul16(mychar);
+            it += 3;
+            *out++ = (char)(nbr & 0xFF);
+        } else {
+            *out++ = *it++;
+        }
+    }
+
+    // adjust length and terminator of the shortened string
+    *out = 0;
+    ai_assert(out > ss.data);
+    ss.length = static_cast<ai_uint32>(out - ss.data);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the contents of the file
+void ColladaParser::ReadContents(XmlNode &node) {
+    const std::string name = node.name();
+    if (name == "COLLADA") {
+        std::string version;
+        if (XmlParser::getStdStrAttribute(node, "version", version)) {
+            aiString v;
+            v.Set(version.c_str());
+            mAssetMetaData.emplace(AI_METADATA_SOURCE_FORMAT_VERSION, v);
+            if (!::strncmp(version.c_str(), "1.5", 3)) {
+                mFormat = FV_1_5_n;
+                ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n");
+            } else if (!::strncmp(version.c_str(), "1.4", 3)) {
+                mFormat = FV_1_4_n;
+                ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n");
+            } else if (!::strncmp(version.c_str(), "1.3", 3)) {
+                mFormat = FV_1_3_n;
+                ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n");
+            }
+        }
+        ReadStructure(node);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the structure of the file
+void ColladaParser::ReadStructure(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "asset") {
+            ReadAssetInfo(currentNode);
+        } else if (currentName == "library_animations") {
+            ReadAnimationLibrary(currentNode);
+        } else if (currentName == "library_animation_clips") {
+            ReadAnimationClipLibrary(currentNode);
+        } else if (currentName == "library_controllers") {
+            ReadControllerLibrary(currentNode);
+        } else if (currentName == "library_images") {
+            ReadImageLibrary(currentNode);
+        } else if (currentName == "library_materials") {
+            ReadMaterialLibrary(currentNode);
+        } else if (currentName == "library_effects") {
+            ReadEffectLibrary(currentNode);
+        } else if (currentName == "library_geometries") {
+            ReadGeometryLibrary(currentNode);
+        } else if (currentName == "library_visual_scenes") {
+            ReadSceneLibrary(currentNode);
+        } else if (currentName == "library_lights") {
+            ReadLightLibrary(currentNode);
+        } else if (currentName == "library_cameras") {
+            ReadCameraLibrary(currentNode);
+        } else if (currentName == "library_nodes") {
+            ReadSceneNode(currentNode, nullptr); /* some hacking to reuse this piece of code */
+        } else if (currentName == "scene") {
+            ReadScene(currentNode);
+        }
+    }
+
+    PostProcessRootAnimations();
+    PostProcessControllers();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads asset information such as coordinate system information and legal blah
+void ColladaParser::ReadAssetInfo(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "unit") {
+            mUnitSize = 1.f;
+            std::string tUnitSizeString;
+            if (XmlParser::getStdStrAttribute(currentNode, "meter", tUnitSizeString)) {
+                try {
+                    fast_atoreal_move<ai_real>(tUnitSizeString.data(), mUnitSize);
+                } catch (const DeadlyImportError& die) {
+                    std::string warning("Collada: Failed to parse meter parameter to real number. Exception:\n");
+                    warning.append(die.what());
+                    ASSIMP_LOG_WARN(warning.data());
+                }
+            }
+        } else if (currentName == "up_axis") {
+            std::string v;
+            if (!XmlParser::getValueAsString(currentNode, v)) {
+                continue;
+            }
+            if (v == "X_UP") {
+                mUpDirection = UP_X;
+            } else if (v == "Z_UP") {
+                mUpDirection = UP_Z;
+            } else {
+                mUpDirection = UP_Y;
+            }
+        } else if (currentName == "contributor") {
+            for (XmlNode currentChildNode : currentNode.children()) {
+                ReadMetaDataItem(currentChildNode, mAssetMetaData);
+            }
+        } else {
+            ReadMetaDataItem(currentNode, mAssetMetaData);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single string metadata item
+void ColladaParser::ReadMetaDataItem(XmlNode &node, StringMetaData &metadata) {
+    const Collada::MetaKeyPairVector &key_renaming = GetColladaAssimpMetaKeysCamelCase();
+    const std::string name = node.name();
+    if (name.empty()) {
+        return;
+    }
+
+    std::string v;
+    if (!XmlParser::getValueAsString(node, v)) {
+        return;
+    }
+
+    v = ai_trim(v);
+    aiString aistr;
+    aistr.Set(v);
+
+    std::string camel_key_str(name);
+    ToCamelCase(camel_key_str);
+
+    size_t found_index;
+    if (FindCommonKey(camel_key_str, key_renaming, found_index)) {
+        metadata.emplace(key_renaming[found_index].second, aistr);
+    } else {
+        metadata.emplace(camel_key_str, aistr);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation clips
+void ColladaParser::ReadAnimationClipLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string animName;
+    if (!XmlParser::getStdStrAttribute(node, "name", animName)) {
+        if (!XmlParser::getStdStrAttribute(node, "id", animName)) {
+            animName = std::string("animation_") + ai_to_string(mAnimationClipLibrary.size());
+        }
+    }
+
+    std::pair<std::string, std::vector<std::string>> clip;
+    clip.first = animName;
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "instance_animation") {
+            std::string url;
+            readUrlAttribute(currentNode, url);
+            clip.second.push_back(url);
+        }
+
+        if (clip.second.size() > 0) {
+            mAnimationClipLibrary.push_back(clip);
+        }
+    }
+}
+
+void ColladaParser::PostProcessControllers() {
+    std::string meshId;
+    for (auto &it : mControllerLibrary) {
+        meshId = it.second.mMeshId;
+        if (meshId.empty()) {
+            continue;
+        }
+
+        ControllerLibrary::iterator findItr = mControllerLibrary.find(meshId);
+        while (findItr != mControllerLibrary.end()) {
+            meshId = findItr->second.mMeshId;
+            findItr = mControllerLibrary.find(meshId);
+        }
+
+        it.second.mMeshId = meshId;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Re-build animations from animation clip library, if present, otherwise combine single-channel animations
+void ColladaParser::PostProcessRootAnimations() {
+    if (mAnimationClipLibrary.empty()) {
+        mAnims.CombineSingleChannelAnimations();
+        return;
+    }
+
+    Animation temp;
+    for (auto &it : mAnimationClipLibrary) {
+        std::string clipName = it.first;
+
+        Animation *clip = new Animation();
+        clip->mName = clipName;
+
+        temp.mSubAnims.push_back(clip);
+
+        for (const std::string &animationID : it.second) {
+            AnimationLibrary::iterator animation = mAnimationLibrary.find(animationID);
+
+            if (animation != mAnimationLibrary.end()) {
+                Animation *pSourceAnimation = animation->second;
+                pSourceAnimation->CollectChannelsRecursively(clip->mChannels);
+            }
+        }
+    }
+
+    mAnims = temp;
+
+    // Ensure no double deletes.
+    temp.mSubAnims.clear();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation library
+void ColladaParser::ReadAnimationLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "animation") {
+            ReadAnimation(currentNode, &mAnims);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation into the given parent structure
+void ColladaParser::ReadAnimation(XmlNode &node, Collada::Animation *pParent) {
+    if (node.empty()) {
+        return;
+    }
+
+    // an <animation> element may be a container for grouping sub-elements or an animation channel
+    // this is the channel collection by ID, in case it has channels
+    using ChannelMap = std::map<std::string, AnimationChannel>;
+    ChannelMap channels;
+    // this is the anim container in case we're a container
+    Animation *anim = nullptr;
+
+    // optional name given as an attribute
+    std::string animName;
+    if (!XmlParser::getStdStrAttribute(node, "name", animName)) {
+        animName = "animation";
+    }
+
+    std::string animID;
+    pugi::xml_attribute idAttr = node.attribute("id");
+    if (idAttr) {
+        animID = idAttr.as_string();
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "animation") {
+            if (!anim) {
+                anim = new Animation;
+                anim->mName = animName;
+                pParent->mSubAnims.push_back(anim);
+            }
+
+            // recurse into the sub-element
+            ReadAnimation(currentNode, anim);
+        } else if (currentName == "source") {
+            ReadSource(currentNode);
+        } else if (currentName == "sampler") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                // have it read into a channel
+                ChannelMap::iterator newChannel = channels.insert(std::make_pair(id, AnimationChannel())).first;
+                ReadAnimationSampler(currentNode, newChannel->second);
+            }
+        } else if (currentName == "channel") {
+            std::string source_name, target;
+            XmlParser::getStdStrAttribute(currentNode, "source", source_name);
+            XmlParser::getStdStrAttribute(currentNode, "target", target);
+            if (source_name[0] == '#') {
+                source_name = source_name.substr(1, source_name.size() - 1);
+            }
+            ChannelMap::iterator cit = channels.find(source_name);
+            if (cit != channels.end()) {
+                cit->second.mTarget = target;
+            }
+        }
+    }
+
+    // it turned out to have channels - add them
+    if (!channels.empty()) {
+        if (nullptr == anim) {
+            anim = new Animation;
+            anim->mName = animName;
+            pParent->mSubAnims.push_back(anim);
+        }
+
+        for (const auto &channel : channels) {
+            anim->mChannels.push_back(channel.second);
+        }
+
+        if (idAttr) {
+            mAnimationLibrary[animID] = anim;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an animation sampler into the given anim channel
+void ColladaParser::ReadAnimationSampler(XmlNode &node, Collada::AnimationChannel &pChannel) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            if (XmlParser::hasAttribute(currentNode, "semantic")) {
+                std::string semantic, sourceAttr;
+                XmlParser::getStdStrAttribute(currentNode, "semantic", semantic);
+                if (XmlParser::hasAttribute(currentNode, "source")) {
+                    XmlParser::getStdStrAttribute(currentNode, "source", sourceAttr);
+                    const char *source = sourceAttr.c_str();
+                    if (source[0] != '#') {
+                        throw DeadlyImportError("Unsupported URL format");
+                    }
+                    source++;
+
+                    if (semantic == "INPUT") {
+                        pChannel.mSourceTimes = source;
+                    } else if (semantic == "OUTPUT") {
+                        pChannel.mSourceValues = source;
+                    } else if (semantic == "IN_TANGENT") {
+                        pChannel.mInTanValues = source;
+                    } else if (semantic == "OUT_TANGENT") {
+                        pChannel.mOutTanValues = source;
+                    } else if (semantic == "INTERPOLATION") {
+                        pChannel.mInterpolationValues = source;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the skeleton controller library
+void ColladaParser::ReadControllerLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName != "controller") {
+            continue;
+        }
+        std::string id;
+        if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+            mControllerLibrary[id] = Controller();
+            ReadController(currentNode, mControllerLibrary[id]);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a controller into the given mesh structure
+void ColladaParser::ReadController(XmlNode &node, Collada::Controller &controller) {
+    // initial values
+    controller.mType = Skin;
+    controller.mMethod = Normalized;
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "morph") {
+            controller.mType = Morph;
+            controller.mMeshId = currentNode.attribute("source").as_string();
+            int methodIndex = currentNode.attribute("method").as_int();
+            if (methodIndex > 0) {
+                std::string method;
+                XmlParser::getValueAsString(currentNode, method);
+
+                if (method == "RELATIVE") {
+                    controller.mMethod = Relative;
+                }
+            }
+        } else if (currentName == "skin") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "source", id)) {
+                controller.mMeshId = id.substr(1, id.size() - 1);
+            }
+        } else if (currentName == "bind_shape_matrix") {
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *content = v.c_str();
+            for (unsigned int a = 0; a < 16; a++) {
+                SkipSpacesAndLineEnd(&content);
+                // read a number
+                content = fast_atoreal_move<ai_real>(content, controller.mBindShapeMatrix[a]);
+                // skip whitespace after it
+                SkipSpacesAndLineEnd(&content);
+            }
+        } else if (currentName == "source") {
+            ReadSource(currentNode);
+        } else if (currentName == "joints") {
+            ReadControllerJoints(currentNode, controller);
+        } else if (currentName == "vertex_weights") {
+            ReadControllerWeights(currentNode, controller);
+        } else if (currentName == "targets") {
+            for (XmlNode currentChildNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+                const std::string &currentChildName = currentChildNode.name();
+                if (currentChildName == "input") {
+                    const char *semantics = currentChildNode.attribute("semantic").as_string();
+                    const char *source = currentChildNode.attribute("source").as_string();
+                    if (strcmp(semantics, "MORPH_TARGET") == 0) {
+                        controller.mMorphTarget = source + 1;
+                    } else if (strcmp(semantics, "MORPH_WEIGHT") == 0) {
+                        controller.mMorphWeight = source + 1;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint definitions for the given controller
+void ColladaParser::ReadControllerJoints(XmlNode &node, Collada::Controller &pController) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            const char *attrSemantic = currentNode.attribute("semantic").as_string();
+            const char *attrSource = currentNode.attribute("source").as_string();
+            if (attrSource[0] != '#') {
+                throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of <joints> data <input> element");
+            }
+            ++attrSource;
+            // parse source URL to corresponding source
+            if (strcmp(attrSemantic, "JOINT") == 0) {
+                pController.mJointNameSource = attrSource;
+            } else if (strcmp(attrSemantic, "INV_BIND_MATRIX") == 0) {
+                pController.mJointOffsetMatrixSource = attrSource;
+            } else {
+                throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in <joints> data <input> element");
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the joint weights for the given controller
+void ColladaParser::ReadControllerWeights(XmlNode &node, Collada::Controller &pController) {
+    // Read vertex count from attributes and resize the array accordingly
+    int vertexCount = 0;
+    XmlParser::getIntAttribute(node, "count", vertexCount);
+    pController.mWeightCounts.resize(vertexCount);
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            InputChannel channel;
+
+            const char *attrSemantic = currentNode.attribute("semantic").as_string();
+            const char *attrSource = currentNode.attribute("source").as_string();
+            channel.mOffset = currentNode.attribute("offset").as_int();
+
+            // local URLS always start with a '#'. We don't support global URLs
+            if (attrSource[0] != '#') {
+                throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of <vertex_weights> data <input> element");
+            }
+            channel.mAccessor = attrSource + 1;
+
+            // parse source URL to corresponding source
+            if (strcmp(attrSemantic, "JOINT") == 0) {
+                pController.mWeightInputJoints = channel;
+            } else if (strcmp(attrSemantic, "WEIGHT") == 0) {
+                pController.mWeightInputWeights = channel;
+            } else {
+                throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in <vertex_weights> data <input> element");
+            }
+        } else if (currentName == "vcount" && vertexCount > 0) {
+            const char *text = currentNode.text().as_string();
+            size_t numWeights = 0;
+            for (std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it) {
+                if (*text == 0) {
+                    throw DeadlyImportError("Out of data while reading <vcount>");
+                }
+
+                *it = strtoul10(text, &text);
+                numWeights += *it;
+                SkipSpacesAndLineEnd(&text);
+            }
+            // reserve weight count
+            pController.mWeights.resize(numWeights);
+        } else if (currentName == "v" && vertexCount > 0) {
+            // read JointIndex - WeightIndex pairs
+            std::string stdText;
+            XmlParser::getValueAsString(currentNode, stdText);
+            const char *text = stdText.c_str();
+            for (std::vector<std::pair<size_t, size_t>>::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it) {
+                if (text == 0) {
+                    throw DeadlyImportError("Out of data while reading <vertex_weights>");
+                }
+                it->first = strtoul10(text, &text);
+                SkipSpacesAndLineEnd(&text);
+                if (*text == 0) {
+                    throw DeadlyImportError("Out of data while reading <vertex_weights>");
+                }
+                it->second = strtoul10(text, &text);
+                SkipSpacesAndLineEnd(&text);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the image library contents
+void ColladaParser::ReadImageLibrary(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "image") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                mImageLibrary[id] = Image();
+                // read on from there
+                ReadImage(currentNode, mImageLibrary[id]);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an image entry into the given image
+void ColladaParser::ReadImage(XmlNode &node, Collada::Image &pImage) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string currentName = currentNode.name();
+        if (currentName == "image") {
+            // Ignore
+            continue;
+        } else if (currentName == "init_from") {
+            if (mFormat == FV_1_4_n) {
+                // FIX: C4D exporter writes empty <init_from/> tags
+                if (!currentNode.empty()) {
+                    // element content is filename - hopefully
+                    const char *sz = currentNode.text().as_string();
+                    if (nullptr != sz) {
+                        aiString filepath(sz);
+                        UriDecodePath(filepath);
+                        pImage.mFileName = filepath.C_Str();
+                    }
+                }
+                if (!pImage.mFileName.length()) {
+                    pImage.mFileName = "unknown_texture";
+                }
+            }
+        } else if (mFormat == FV_1_5_n) {
+            std::string value;
+            XmlNode refChild = currentNode.child("ref");
+            XmlNode hexChild = currentNode.child("hex");
+            if (refChild) {
+                // element content is filename - hopefully
+                if (XmlParser::getValueAsString(refChild, value)) {
+                    aiString filepath(value);
+                    UriDecodePath(filepath);
+                    pImage.mFileName = filepath.C_Str();
+                }
+            } else if (hexChild && !pImage.mFileName.length()) {
+                // embedded image. get format
+                pImage.mEmbeddedFormat = hexChild.attribute("format").as_string();
+                if (pImage.mEmbeddedFormat.empty()) {
+                    ASSIMP_LOG_WARN("Collada: Unknown image file format");
+                }
+
+                XmlParser::getValueAsString(hexChild, value);
+                const char *data = value.c_str();
+                // hexadecimal-encoded binary octets. First of all, find the
+                // required buffer size to reserve enough storage.
+                const char *cur = data;
+                while (!IsSpaceOrNewLine(*cur)) {
+                    ++cur;
+                }
+
+                const unsigned int size = (unsigned int)(cur - data) * 2;
+                pImage.mImageData.resize(size);
+                for (unsigned int i = 0; i < size; ++i) {
+                    pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1));
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the material library
+void ColladaParser::ReadMaterialLibrary(XmlNode &node) {
+    std::map<std::string, int> names;
+    for (XmlNode &currentNode : node.children()) {
+        std::string id = currentNode.attribute("id").as_string();
+        std::string name = currentNode.attribute("name").as_string();
+        mMaterialLibrary[id] = Material();
+
+        if (!name.empty()) {
+            std::map<std::string, int>::iterator it = names.find(name);
+            if (it != names.end()) {
+                std::ostringstream strStream;
+                strStream << ++it->second;
+                name.append(" " + strStream.str());
+            } else {
+                names[name] = 0;
+            }
+
+            mMaterialLibrary[id].mName = name;
+        }
+
+        ReadMaterial(currentNode, mMaterialLibrary[id]);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the light library
+void ColladaParser::ReadLightLibrary(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "light") {
+            std::string id;
+            if (XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                ReadLight(currentNode, mLightLibrary[id] = Light());
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the camera library
+void ColladaParser::ReadCameraLibrary(XmlNode &node) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "camera") {
+            std::string id;
+            if (!XmlParser::getStdStrAttribute(currentNode, "id", id)) {
+                continue;
+            }
+
+            // create an entry and store it in the library under its ID
+            Camera &cam = mCameraLibrary[id];
+            std::string name;
+            if (!XmlParser::getStdStrAttribute(currentNode, "name", name)) {
+                continue;
+            }
+            if (!name.empty()) {
+                cam.mName = name;
+            }
+            ReadCamera(currentNode, cam);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a material entry into the given material
+void ColladaParser::ReadMaterial(XmlNode &node, Collada::Material &pMaterial) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "instance_effect") {
+            std::string url;
+            readUrlAttribute(currentNode, url);
+            pMaterial.mEffect = url;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a light entry into the given light
+void ColladaParser::ReadLight(XmlNode &node, Collada::Light &pLight) {
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    // TODO: Check the current technique and skip over unsupported extra techniques
+
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "spot") {
+            pLight.mType = aiLightSource_SPOT;
+        } else if (currentName == "ambient") {
+            pLight.mType = aiLightSource_AMBIENT;
+        } else if (currentName == "directional") {
+            pLight.mType = aiLightSource_DIRECTIONAL;
+        } else if (currentName == "point") {
+            pLight.mType = aiLightSource_POINT;
+        } else if (currentName == "color") {
+            // text content contains 3 floats
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *content = v.c_str();
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.r);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.g);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.b);
+            SkipSpacesAndLineEnd(&content);
+        } else if (currentName == "constant_attenuation") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mAttConstant);
+        } else if (currentName == "linear_attenuation") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mAttLinear);
+        } else if (currentName == "quadratic_attenuation") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mAttQuadratic);
+        } else if (currentName == "falloff_angle") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle);
+        } else if (currentName == "falloff_exponent") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mFalloffExponent);
+        }
+        // FCOLLADA extensions
+        // -------------------------------------------------------
+        else if (currentName == "outer_cone") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
+        } else if (currentName == "penumbra_angle") { // this one is deprecated, now calculated using outer_cone
+            XmlParser::getValueAsFloat(currentNode, pLight.mPenumbraAngle);
+        } else if (currentName == "intensity") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mIntensity);
+        }
+        else if (currentName == "falloff") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
+        } else if (currentName == "hotspot_beam") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle);
+        }
+        // OpenCOLLADA extensions
+        // -------------------------------------------------------
+        else if (currentName == "decay_falloff") {
+            XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a camera entry into the given light
+void ColladaParser::ReadCamera(XmlNode &node, Collada::Camera &camera) {
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "orthographic") {
+            camera.mOrtho = true;
+        } else if (currentName == "xfov" || currentName == "xmag") {
+            XmlParser::getValueAsFloat(currentNode, camera.mHorFov);
+        } else if (currentName == "yfov" || currentName == "ymag") {
+            XmlParser::getValueAsFloat(currentNode, camera.mVerFov);
+        } else if (currentName == "aspect_ratio") {
+            XmlParser::getValueAsFloat(currentNode, camera.mAspect);
+        } else if (currentName == "znear") {
+            XmlParser::getValueAsFloat(currentNode, camera.mZNear);
+        } else if (currentName == "zfar") {
+            XmlParser::getValueAsFloat(currentNode, camera.mZFar);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the effect library
+void ColladaParser::ReadEffectLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "effect") {
+            // read ID. Do I have to repeat my ranting about "optional" attributes?
+            std::string id;
+            XmlParser::getStdStrAttribute(currentNode, "id", id);
+
+            // create an entry and store it in the library under its ID
+            mEffectLibrary[id] = Effect();
+
+            // read on from there
+            ReadEffect(currentNode, mEffectLibrary[id]);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry into the given effect
+void ColladaParser::ReadEffect(XmlNode &node, Collada::Effect &pEffect) {
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "profile_COMMON") {
+            ReadEffectProfileCommon(currentNode, pEffect);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an COMMON effect profile
+void ColladaParser::ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect) {
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string currentName = currentNode.name();
+        if (currentName == "newparam") {
+            // save ID
+            std::string sid = currentNode.attribute("sid").as_string();
+            pEffect.mParams[sid] = EffectParam();
+            ReadEffectParam(currentNode, pEffect.mParams[sid]);
+        } else if (currentName == "technique" || currentName == "extra") {
+            // just syntactic sugar
+        } else if (mFormat == FV_1_4_n && currentName == "image") {
+            // read ID. Another entry which is "optional" by design but obligatory in reality
+            std::string id = currentNode.attribute("id").as_string();
+
+            // create an entry and store it in the library under its ID
+            mImageLibrary[id] = Image();
+
+            // read on from there
+            ReadImage(currentNode, mImageLibrary[id]);
+        } else if (currentName == "phong")
+            pEffect.mShadeType = Shade_Phong;
+        else if (currentName == "constant")
+            pEffect.mShadeType = Shade_Constant;
+        else if (currentName == "lambert")
+            pEffect.mShadeType = Shade_Lambert;
+        else if (currentName == "blinn")
+            pEffect.mShadeType = Shade_Blinn;
+
+        /* Color + texture properties */
+        else if (currentName == "emission")
+            ReadEffectColor(currentNode, pEffect.mEmissive, pEffect.mTexEmissive);
+        else if (currentName == "ambient")
+            ReadEffectColor(currentNode, pEffect.mAmbient, pEffect.mTexAmbient);
+        else if (currentName == "diffuse")
+            ReadEffectColor(currentNode, pEffect.mDiffuse, pEffect.mTexDiffuse);
+        else if (currentName == "specular")
+            ReadEffectColor(currentNode, pEffect.mSpecular, pEffect.mTexSpecular);
+        else if (currentName == "reflective") {
+            ReadEffectColor(currentNode, pEffect.mReflective, pEffect.mTexReflective);
+        } else if (currentName == "transparent") {
+            pEffect.mHasTransparency = true;
+            const char *opaque = currentNode.attribute("opaque").as_string();
+            //const char *opaque = mReader->getAttributeValueSafe("opaque");
+
+            if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) {
+                pEffect.mRGBTransparency = true;
+            }
+
+            // In RGB_ZERO mode, the transparency is interpreted in reverse, go figure...
+            if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "A_ZERO") == 0) {
+                pEffect.mInvertTransparency = true;
+            }
+
+            ReadEffectColor(currentNode, pEffect.mTransparent, pEffect.mTexTransparent);
+        } else if (currentName == "shininess")
+            ReadEffectFloat(currentNode, pEffect.mShininess);
+        else if (currentName == "reflectivity")
+            ReadEffectFloat(currentNode, pEffect.mReflectivity);
+
+        /* Single scalar properties */
+        else if (currentName == "transparency")
+            ReadEffectFloat(currentNode, pEffect.mTransparency);
+        else if (currentName == "index_of_refraction")
+            ReadEffectFloat(currentNode, pEffect.mRefractIndex);
+
+        // GOOGLEEARTH/OKINO extensions
+        // -------------------------------------------------------
+        else if (currentName == "double_sided")
+            XmlParser::getValueAsBool(currentNode, pEffect.mDoubleSided);
+
+        // FCOLLADA extensions
+        // -------------------------------------------------------
+        else if (currentName == "bump") {
+            aiColor4D dummy;
+            ReadEffectColor(currentNode, dummy, pEffect.mTexBump);
+        }
+
+        // MAX3D extensions
+        // -------------------------------------------------------
+        else if (currentName == "wireframe") {
+            XmlParser::getValueAsBool(currentNode, pEffect.mWireframe);
+        } else if (currentName == "faceted") {
+            XmlParser::getValueAsBool(currentNode, pEffect.mFaceted);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Read texture wrapping + UV transform settings from a profile==Maya chunk
+void ColladaParser::ReadSamplerProperties(XmlNode &node, Sampler &out) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        // MAYA extensions
+        // -------------------------------------------------------
+        if (currentName == "wrapU") {
+            XmlParser::getValueAsBool(currentNode, out.mWrapU);
+        } else if (currentName == "wrapV") {
+            XmlParser::getValueAsBool(currentNode, out.mWrapV);
+        } else if (currentName == "mirrorU") {
+            XmlParser::getValueAsBool(currentNode, out.mMirrorU);
+        } else if (currentName == "mirrorV") {
+            XmlParser::getValueAsBool(currentNode, out.mMirrorV);
+        } else if (currentName == "repeatU") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.x);
+        } else if (currentName == "repeatV") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.y);
+        } else if (currentName == "offsetU") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.x);
+        } else if (currentName == "offsetV") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.y);
+        } else if (currentName == "rotateUV") {
+            XmlParser::getValueAsFloat(currentNode, out.mTransform.mRotation);
+        } else if (currentName == "blend_mode") {
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *sz = v.c_str();
+            // http://www.feelingsoftware.com/content/view/55/72/lang,en/
+            // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE
+            if (0 == ASSIMP_strincmp(sz, "ADD", 3))
+                out.mOp = aiTextureOp_Add;
+            else if (0 == ASSIMP_strincmp(sz, "SUBTRACT", 8))
+                out.mOp = aiTextureOp_Subtract;
+            else if (0 == ASSIMP_strincmp(sz, "MULTIPLY", 8))
+                out.mOp = aiTextureOp_Multiply;
+            else {
+                ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode");
+            }
+        }
+        // OKINO extensions
+        // -------------------------------------------------------
+        else if (currentName == "weighting") {
+            XmlParser::getValueAsFloat(currentNode, out.mWeighting);
+        } else if (currentName == "mix_with_previous_layer") {
+            XmlParser::getValueAsFloat(currentNode, out.mMixWithPrevious);
+        }
+        // MAX3D extensions
+        // -------------------------------------------------------
+        else if (currentName == "amount") {
+            XmlParser::getValueAsFloat(currentNode, out.mWeighting);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a color or a texture defining that color
+void ColladaParser::ReadEffectColor(XmlNode &node, aiColor4D &pColor, Sampler &pSampler) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "color") {
+            // text content contains 4 floats
+            std::string v;
+            XmlParser::getValueAsString(currentNode, v);
+            const char *content = v.c_str();
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.r);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.g);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.b);
+            SkipSpacesAndLineEnd(&content);
+
+            content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.a);
+            SkipSpacesAndLineEnd(&content);
+        } else if (currentName == "texture") {
+            // get name of source texture/sampler
+            XmlParser::getStdStrAttribute(currentNode, "texture", pSampler.mName);
+
+            // get name of UV source channel. Specification demands it to be there, but some exporters
+            // don't write it. It will be the default UV channel in case it's missing.
+            XmlParser::getStdStrAttribute(currentNode, "texcoord", pSampler.mUVChannel);
+
+            // as we've read texture, the color needs to be 1,1,1,1
+            pColor = aiColor4D(1.f, 1.f, 1.f, 1.f);
+        } else if (currentName == "technique") {
+            std::string profile;
+            XmlParser::getStdStrAttribute(currentNode, "profile", profile);
+
+            // Some extensions are quite useful ... ReadSamplerProperties processes
+            // several extensions in MAYA, OKINO and MAX3D profiles.
+            if (!::strcmp(profile.c_str(), "MAYA") || !::strcmp(profile.c_str(), "MAX3D") || !::strcmp(profile.c_str(), "OKINO")) {
+                // get more information on this sampler
+                ReadSamplerProperties(currentNode, pSampler);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect entry containing a float
+void ColladaParser::ReadEffectFloat(XmlNode &node, ai_real &pFloat) {
+    pFloat = 0.f;
+    XmlNode floatNode = node.child("float");
+    if (floatNode.empty()) {
+        return;
+    }
+    XmlParser::getValueAsFloat(floatNode, pFloat);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an effect parameter specification of any kind
+void ColladaParser::ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "surface") {
+            // image ID given inside <init_from> tags
+            XmlNode initNode = currentNode.child("init_from");
+            if (initNode) {
+                std::string v;
+                XmlParser::getValueAsString(initNode, v);
+                pParam.mType = Param_Surface;
+                pParam.mReference = v.c_str();
+            }
+        } else if (currentName == "sampler2D" && (FV_1_4_n == mFormat || FV_1_3_n == mFormat)) {
+            // surface ID is given inside <source> tags
+            const char *content = currentNode.value();
+            pParam.mType = Param_Sampler;
+            pParam.mReference = content;
+        } else if (currentName == "sampler2D") {
+            // surface ID is given inside <instance_image> tags
+            std::string url;
+            XmlParser::getStdStrAttribute(currentNode, "url", url);
+            if (url[0] != '#') {
+                throw DeadlyImportError("Unsupported URL format in instance_image");
+            }
+            pParam.mType = Param_Sampler;
+            pParam.mReference = url.c_str() + 1;
+        } else if (currentName == "source") {
+            const char *source = currentNode.child_value();
+            if (nullptr != source) {
+                pParam.mReference = source;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the geometry library contents
+void ColladaParser::ReadGeometryLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "geometry") {
+            // read ID. Another entry which is "optional" by design but obligatory in reality
+
+            std::string id;
+            XmlParser::getStdStrAttribute(currentNode, "id", id);
+            // create a mesh and store it in the library under its (resolved) ID
+            // Skip and warn if ID is not unique
+            if (mMeshLibrary.find(id) == mMeshLibrary.cend()) {
+                std::unique_ptr<Mesh> mesh(new Mesh(id));
+
+                XmlParser::getStdStrAttribute(currentNode, "name", mesh->mName);
+
+                // read on from there
+                ReadGeometry(currentNode, *mesh);
+                // Read successfully, add to library
+                mMeshLibrary.insert({ id, mesh.release() });
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a geometry from the geometry library.
+void ColladaParser::ReadGeometry(XmlNode &node, Collada::Mesh &pMesh) {
+    if (node.empty()) {
+        return;
+    }
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "mesh") {
+            ReadMesh(currentNode, pMesh);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh from the geometry library
+void ColladaParser::ReadMesh(XmlNode &node, Mesh &pMesh) {
+    if (node.empty()) {
+        return;
+    }
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "source") {
+            ReadSource(currentNode);
+        } else if (currentName == "vertices") {
+            ReadVertexData(currentNode, pMesh);
+        } else if (currentName == "triangles" || currentName == "lines" || currentName == "linestrips" ||
+                   currentName == "polygons" || currentName == "polylist" || currentName == "trifans" ||
+                   currentName == "tristrips") {
+            ReadIndexData(currentNode, pMesh);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a source element
+void ColladaParser::ReadSource(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string sourceID;
+    XmlParser::getStdStrAttribute(node, "id", sourceID);
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "float_array" || currentName == "IDREF_array" || currentName == "Name_array") {
+            ReadDataArray(currentNode);
+        } else if (currentName == "technique_common") {
+            XmlNode technique = currentNode.child("accessor");
+            if (!technique.empty()) {
+                ReadAccessor(technique, sourceID);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a data array holding a number of floats, and stores it in the global library
+void ColladaParser::ReadDataArray(XmlNode &node) {
+    std::string name = node.name();
+    bool isStringArray = (name == "IDREF_array" || name == "Name_array");
+
+    // read attributes
+    std::string id;
+    XmlParser::getStdStrAttribute(node, "id", id);
+    unsigned int count = 0;
+    XmlParser::getUIntAttribute(node, "count", count);
+    std::string v;
+    XmlParser::getValueAsString(node, v);
+    v = ai_trim(v);
+    const char *content = v.c_str();
+
+    // read values and store inside an array in the data library
+    mDataLibrary[id] = Data();
+    Data &data = mDataLibrary[id];
+    data.mIsStringArray = isStringArray;
+
+    // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them
+    if (content) {
+        if (isStringArray) {
+            data.mStrings.reserve(count);
+            std::string s;
+
+            for (unsigned int a = 0; a < count; a++) {
+                if (*content == 0) {
+                    throw DeadlyImportError("Expected more values while reading IDREF_array contents.");
+                }
+
+                s.clear();
+                while (!IsSpaceOrNewLine(*content))
+                    s += *content++;
+                data.mStrings.push_back(s);
+
+                SkipSpacesAndLineEnd(&content);
+            }
+        } else {
+            data.mValues.reserve(count);
+
+            for (unsigned int a = 0; a < count; a++) {
+                if (*content == 0) {
+                    throw DeadlyImportError("Expected more values while reading float_array contents.");
+                }
+
+                // read a number
+                ai_real value;
+                content = fast_atoreal_move<ai_real>(content, value);
+                data.mValues.push_back(value);
+                // skip whitespace after it
+                SkipSpacesAndLineEnd(&content);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an accessor and stores it in the global library
+void ColladaParser::ReadAccessor(XmlNode &node, const std::string &pID) {
+    // read accessor attributes
+    std::string source;
+    XmlParser::getStdStrAttribute(node, "source", source);
+    if (source[0] != '#') {
+        throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of <accessor> element.");
+    }
+    int count = 0;
+    XmlParser::getIntAttribute(node, "count", count);
+
+    unsigned int offset = 0;
+    if (XmlParser::hasAttribute(node, "offset")) {
+        XmlParser::getUIntAttribute(node, "offset", offset);
+    }
+    unsigned int stride = 1;
+    if (XmlParser::hasAttribute(node, "stride")) {
+        XmlParser::getUIntAttribute(node, "stride", stride);
+    }
+    // store in the library under the given ID
+    mAccessorLibrary[pID] = Accessor();
+    Accessor &acc = mAccessorLibrary[pID];
+    acc.mCount = count;
+    acc.mOffset = offset;
+    acc.mStride = stride;
+    acc.mSource = source.c_str() + 1; // ignore the leading '#'
+    acc.mSize = 0; // gets incremented with every param
+
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "param") {
+            // read data param
+            std::string name;
+            if (XmlParser::hasAttribute(currentNode, "name")) {
+                XmlParser::getStdStrAttribute(currentNode, "name", name);
+
+                // analyse for common type components and store it's sub-offset in the corresponding field
+
+                // Cartesian coordinates
+                if (name == "X")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "Y")
+                    acc.mSubOffset[1] = acc.mParams.size();
+                else if (name == "Z")
+                    acc.mSubOffset[2] = acc.mParams.size();
+
+                /* RGBA colors */
+                else if (name == "R")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "G")
+                    acc.mSubOffset[1] = acc.mParams.size();
+                else if (name == "B")
+                    acc.mSubOffset[2] = acc.mParams.size();
+                else if (name == "A")
+                    acc.mSubOffset[3] = acc.mParams.size();
+
+                /* UVWQ (STPQ) texture coordinates */
+                else if (name == "S")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "T")
+                    acc.mSubOffset[1] = acc.mParams.size();
+                else if (name == "P")
+                    acc.mSubOffset[2] = acc.mParams.size();
+                /* Generic extra data, interpreted as UV data, too*/
+                else if (name == "U")
+                    acc.mSubOffset[0] = acc.mParams.size();
+                else if (name == "V")
+                    acc.mSubOffset[1] = acc.mParams.size();
+            }
+            if (XmlParser::hasAttribute(currentNode, "type")) {
+                // read data type
+                // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types
+                // which should be tested for here.
+                std::string type;
+
+                XmlParser::getStdStrAttribute(currentNode, "type", type);
+                if (type == "float4x4")
+                    acc.mSize += 16;
+                else
+                    acc.mSize += 1;
+            }
+
+            acc.mParams.push_back(name);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-vertex mesh data into the given mesh
+void ColladaParser::ReadVertexData(XmlNode &node, Mesh &pMesh) {
+    // extract the ID of the <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
+    XmlParser::getStdStrAttribute(node, "id", pMesh.mVertexID);
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            ReadInputChannel(currentNode, pMesh.mPerVertexData);
+        } else {
+            throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <vertices>");
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-index mesh data into the given mesh
+void ColladaParser::ReadIndexData(XmlNode &node, Mesh &pMesh) {
+    std::vector<size_t> vcount;
+    std::vector<InputChannel> perIndexData;
+
+    unsigned int numPrimitives = 0;
+    XmlParser::getUIntAttribute(node, "count", numPrimitives);
+    // read primitive count from the attribute
+    //int attrCount = GetAttribute("count");
+    //size_t numPrimitives = (size_t)mReader->getAttributeValueAsInt(attrCount);
+    // some mesh types (e.g. tristrips) don't specify primitive count upfront,
+    // so we need to sum up the actual number of primitives while we read the <p>-tags
+    size_t actualPrimitives = 0;
+    SubMesh subgroup;
+    if (XmlParser::hasAttribute(node, "material")) {
+        XmlParser::getStdStrAttribute(node, "material", subgroup.mMaterial);
+    }
+
+    // distinguish between polys and triangles
+    std::string elementName = node.name();
+    PrimitiveType primType = Prim_Invalid;
+    if (elementName == "lines")
+        primType = Prim_Lines;
+    else if (elementName == "linestrips")
+        primType = Prim_LineStrip;
+    else if (elementName == "polygons")
+        primType = Prim_Polygon;
+    else if (elementName == "polylist")
+        primType = Prim_Polylist;
+    else if (elementName == "triangles")
+        primType = Prim_Triangles;
+    else if (elementName == "trifans")
+        primType = Prim_TriFans;
+    else if (elementName == "tristrips")
+        primType = Prim_TriStrips;
+
+    ai_assert(primType != Prim_Invalid);
+
+    // also a number of <input> elements, but in addition a <p> primitive collection and probably index counts for all primitives
+    XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+    XmlNode currentNode;
+    while (xmlIt.getNext(currentNode)) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "input") {
+            ReadInputChannel(currentNode, perIndexData);
+        } else if (currentName == "vcount") {
+            if (!currentNode.empty()) {
+                if (numPrimitives) // It is possible to define a mesh without any primitives
+                {
+                    // case <polylist> - specifies the number of indices for each polygon
+                    std::string v;
+                    XmlParser::getValueAsString(currentNode, v);
+                    const char *content = v.c_str();
+                    vcount.reserve(numPrimitives);
+                    for (unsigned int a = 0; a < numPrimitives; a++) {
+                        if (*content == 0) {
+                            throw DeadlyImportError("Expected more values while reading <vcount> contents.");
+                        }
+                        // read a number
+                        vcount.push_back((size_t)strtoul10(content, &content));
+                        // skip whitespace after it
+                        SkipSpacesAndLineEnd(&content);
+                    }
+                }
+            }
+        } else if (currentName == "p") {
+            if (!currentNode.empty()) {
+                // now here the actual fun starts - these are the indices to construct the mesh data from
+                actualPrimitives += ReadPrimitives(currentNode, pMesh, perIndexData, numPrimitives, vcount, primType);
+            }
+        } else if (currentName == "extra") {
+            // skip
+        } else if (currentName == "ph") {
+            // skip
+        } else {
+            throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <", elementName, ">");
+        }
+    }
+
+#ifdef ASSIMP_BUILD_DEBUG
+    if (primType != Prim_TriFans && primType != Prim_TriStrips && primType != Prim_LineStrip &&
+            primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'.
+        ai_assert(actualPrimitives == numPrimitives);
+    }
+#endif
+
+    // only when we're done reading all <p> tags (and thus know the final vertex count) can we commit the submesh
+    subgroup.mNumFaces = actualPrimitives;
+    pMesh.mSubMeshes.push_back(subgroup);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single input channel element and stores it in the given array, if valid
+void ColladaParser::ReadInputChannel(XmlNode &node, std::vector<InputChannel> &poChannels) {
+    InputChannel channel;
+
+    // read semantic
+    std::string semantic;
+    XmlParser::getStdStrAttribute(node, "semantic", semantic);
+    channel.mType = GetTypeForSemantic(semantic);
+
+    // read source
+    std::string source;
+    XmlParser::getStdStrAttribute(node, "source", source);
+    if (source[0] != '#') {
+        throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of <input> element.");
+    }
+    channel.mAccessor = source.c_str() + 1; // skipping the leading #, hopefully the remaining text is the accessor ID only
+
+    // read index offset, if per-index <input>
+    if (XmlParser::hasAttribute(node, "offset")) {
+        XmlParser::getUIntAttribute(node, "offset", (unsigned int &)channel.mOffset);
+    }
+
+    // read set if texture coordinates
+    if (channel.mType == IT_Texcoord || channel.mType == IT_Color) {
+        unsigned int attrSet = 0;
+        if (XmlParser::getUIntAttribute(node, "set", attrSet))
+            channel.mIndex = attrSet;
+    }
+
+    // store, if valid type
+    if (channel.mType != IT_Invalid)
+        poChannels.push_back(channel);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a <p> primitive index list and assembles the mesh data into the given mesh
+size_t ColladaParser::ReadPrimitives(XmlNode &node, Mesh &pMesh, std::vector<InputChannel> &pPerIndexChannels,
+        size_t pNumPrimitives, const std::vector<size_t> &pVCount, PrimitiveType pPrimType) {
+    // determine number of indices coming per vertex
+    // find the offset index for all per-vertex channels
+    size_t numOffsets = 1;
+    size_t perVertexOffset = SIZE_MAX; // invalid value
+    for (const InputChannel &channel : pPerIndexChannels) {
+        numOffsets = std::max(numOffsets, channel.mOffset + 1);
+        if (channel.mType == IT_Vertex)
+            perVertexOffset = channel.mOffset;
+    }
+
+    // determine the expected number of indices
+    size_t expectedPointCount = 0;
+    switch (pPrimType) {
+    case Prim_Polylist: {
+        for (size_t i : pVCount)
+            expectedPointCount += i;
+        break;
+    }
+    case Prim_Lines:
+        expectedPointCount = 2 * pNumPrimitives;
+        break;
+    case Prim_Triangles:
+        expectedPointCount = 3 * pNumPrimitives;
+        break;
+    default:
+        // other primitive types don't state the index count upfront... we need to guess
+        break;
+    }
+
+    // and read all indices into a temporary array
+    std::vector<size_t> indices;
+    if (expectedPointCount > 0) {
+        indices.reserve(expectedPointCount * numOffsets);
+    }
+
+    // It is possible to not contain any indices
+    if (pNumPrimitives > 0) {
+        std::string v;
+        XmlParser::getValueAsString(node, v);
+        const char *content = v.c_str();
+        SkipSpacesAndLineEnd(&content);
+        while (*content != 0) {
+            // read a value.
+            // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways.
+            int value = std::max(0, strtol10(content, &content));
+            indices.push_back(size_t(value));
+            // skip whitespace after it
+            SkipSpacesAndLineEnd(&content);
+        }
+    }
+
+    // complain if the index count doesn't fit
+    if (expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) {
+        if (pPrimType == Prim_Lines) {
+            // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines'
+            ReportWarning("Expected different index count in <p> element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets);
+            pNumPrimitives = (indices.size() / numOffsets) / 2;
+        } else {
+            throw DeadlyImportError("Expected different index count in <p> element.");
+        }
+    } else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0) {
+        throw DeadlyImportError("Expected different index count in <p> element.");
+    }
+
+    // find the data for all sources
+    for (std::vector<InputChannel>::iterator it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) {
+        InputChannel &input = *it;
+        if (input.mResolved) {
+            continue;
+        }
+
+        // find accessor
+        input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
+        // resolve accessor's data pointer as well, if necessary
+        const Accessor *acc = input.mResolved;
+        if (!acc->mData) {
+            acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
+        }
+    }
+    // and the same for the per-index channels
+    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) {
+        InputChannel &input = *it;
+        if (input.mResolved) {
+            continue;
+        }
+
+        // ignore vertex pointer, it doesn't refer to an accessor
+        if (input.mType == IT_Vertex) {
+            // warn if the vertex channel does not refer to the <vertices> element in the same mesh
+            if (input.mAccessor != pMesh.mVertexID) {
+                throw DeadlyImportError("Unsupported vertex referencing scheme.");
+            }
+            continue;
+        }
+
+        // find accessor
+        input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor);
+        // resolve accessor's data pointer as well, if necessary
+        const Accessor *acc = input.mResolved;
+        if (!acc->mData) {
+            acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource);
+        }
+    }
+
+    // For continued primitives, the given count does not come all in one <p>, but only one primitive per <p>
+    size_t numPrimitives = pNumPrimitives;
+    if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
+        numPrimitives = 1;
+    // For continued primitives, the given count is actually the number of <p>'s inside the parent tag
+    if (pPrimType == Prim_TriStrips) {
+        size_t numberOfVertices = indices.size() / numOffsets;
+        numPrimitives = numberOfVertices - 2;
+    }
+    if (pPrimType == Prim_LineStrip) {
+        size_t numberOfVertices = indices.size() / numOffsets;
+        numPrimitives = numberOfVertices - 1;
+    }
+
+    pMesh.mFaceSize.reserve(numPrimitives);
+    pMesh.mFacePosIndices.reserve(indices.size() / numOffsets);
+
+    size_t polylistStartVertex = 0;
+    for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++) {
+        // determine number of points for this primitive
+        size_t numPoints = 0;
+        switch (pPrimType) {
+        case Prim_Lines:
+            numPoints = 2;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_LineStrip:
+            numPoints = 2;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_Triangles:
+            numPoints = 3;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_TriStrips:
+            numPoints = 3;
+            ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        case Prim_Polylist:
+            numPoints = pVCount[currentPrimitive];
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices);
+            polylistStartVertex += numPoints;
+            break;
+        case Prim_TriFans:
+        case Prim_Polygon:
+            numPoints = indices.size() / numOffsets;
+            for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++)
+                CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+            break;
+        default:
+            // LineStrip is not supported due to expected index unmangling
+            throw DeadlyImportError("Unsupported primitive type.");
+            break;
+        }
+
+        // store the face size to later reconstruct the face from
+        pMesh.mFaceSize.push_back(numPoints);
+    }
+
+    // if I ever get my hands on that guy who invented this steaming pile of indirection...
+    return numPrimitives;
+}
+
+///@note This function won't work correctly if both PerIndex and PerVertex channels have same channels.
+///For example if TEXCOORD present in both <vertices> and <polylist> tags this function will create wrong uv coordinates.
+///It's not clear from COLLADA documentation is this allowed or not. For now only exporter fixed to avoid such behavior
+void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh &pMesh,
+        std::vector<InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &indices) {
+    // calculate the base offset of the vertex whose attributes we ant to copy
+    size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
+
+    // don't overrun the boundaries of the index list
+    ai_assert((baseOffset + numOffsets - 1) < indices.size());
+
+    // extract per-vertex channels using the global per-vertex offset
+    for (std::vector<InputChannel>::iterator it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) {
+        ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh);
+    }
+    // and extract per-index channels using there specified offset
+    for (std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) {
+        ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh);
+    }
+
+    // store the vertex-data index for later assignment of bone vertex weights
+    pMesh.mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]);
+}
+
+void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh &pMesh, std::vector<InputChannel> &pPerIndexChannels,
+        size_t currentPrimitive, const std::vector<size_t> &indices) {
+    if (currentPrimitive % 2 != 0) {
+        //odd tristrip triangles need their indices mangled, to preserve winding direction
+        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+    } else { //for non tristrips or even tristrip triangles
+        CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+        CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Extracts a single object from an input channel and stores it in the appropriate mesh data array
+void ColladaParser::ExtractDataObjectFromChannel(const InputChannel &pInput, size_t pLocalIndex, Mesh &pMesh) {
+    // ignore vertex referrer - we handle them that separate
+    if (pInput.mType == IT_Vertex) {
+        return;
+    }
+
+    const Accessor &acc = *pInput.mResolved;
+    if (pLocalIndex >= acc.mCount) {
+        throw DeadlyImportError("Invalid data index (", pLocalIndex, "/", acc.mCount, ") in primitive specification");
+    }
+
+    // get a pointer to the start of the data object referred to by the accessor and the local index
+    const ai_real *dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex * acc.mStride;
+
+    // assemble according to the accessors component sub-offset list. We don't care, yet,
+    // what kind of object exactly we're extracting here
+    ai_real obj[4];
+    for (size_t c = 0; c < 4; ++c) {
+        obj[c] = dataObject[acc.mSubOffset[c]];
+    }
+
+    // now we reinterpret it according to the type we're reading here
+    switch (pInput.mType) {
+    case IT_Position: // ignore all position streams except 0 - there can be only one position
+        if (pInput.mIndex == 0) {
+            pMesh.mPositions.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported");
+        }
+        break;
+    case IT_Normal:
+        // pad to current vertex count if necessary
+        if (pMesh.mNormals.size() < pMesh.mPositions.size() - 1)
+            pMesh.mNormals.insert(pMesh.mNormals.end(), pMesh.mPositions.size() - pMesh.mNormals.size() - 1, aiVector3D(0, 1, 0));
+
+        // ignore all normal streams except 0 - there can be only one normal
+        if (pInput.mIndex == 0) {
+            pMesh.mNormals.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported");
+        }
+        break;
+    case IT_Tangent:
+        // pad to current vertex count if necessary
+        if (pMesh.mTangents.size() < pMesh.mPositions.size() - 1)
+            pMesh.mTangents.insert(pMesh.mTangents.end(), pMesh.mPositions.size() - pMesh.mTangents.size() - 1, aiVector3D(1, 0, 0));
+
+        // ignore all tangent streams except 0 - there can be only one tangent
+        if (pInput.mIndex == 0) {
+            pMesh.mTangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported");
+        }
+        break;
+    case IT_Bitangent:
+        // pad to current vertex count if necessary
+        if (pMesh.mBitangents.size() < pMesh.mPositions.size() - 1) {
+            pMesh.mBitangents.insert(pMesh.mBitangents.end(), pMesh.mPositions.size() - pMesh.mBitangents.size() - 1, aiVector3D(0, 0, 1));
+        }
+
+        // ignore all bitangent streams except 0 - there can be only one bitangent
+        if (pInput.mIndex == 0) {
+            pMesh.mBitangents.push_back(aiVector3D(obj[0], obj[1], obj[2]));
+        } else {
+            ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported");
+        }
+        break;
+    case IT_Texcoord:
+        // up to 4 texture coord sets are fine, ignore the others
+        if (pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+            // pad to current vertex count if necessary
+            if (pMesh.mTexCoords[pInput.mIndex].size() < pMesh.mPositions.size() - 1)
+                pMesh.mTexCoords[pInput.mIndex].insert(pMesh.mTexCoords[pInput.mIndex].end(),
+                        pMesh.mPositions.size() - pMesh.mTexCoords[pInput.mIndex].size() - 1, aiVector3D(0, 0, 0));
+
+            pMesh.mTexCoords[pInput.mIndex].push_back(aiVector3D(obj[0], obj[1], obj[2]));
+            if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) {
+                pMesh.mNumUVComponents[pInput.mIndex] = 3;
+            }
+        } else {
+            ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping.");
+        }
+        break;
+    case IT_Color:
+        // up to 4 color sets are fine, ignore the others
+        if (pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS) {
+            // pad to current vertex count if necessary
+            if (pMesh.mColors[pInput.mIndex].size() < pMesh.mPositions.size() - 1)
+                pMesh.mColors[pInput.mIndex].insert(pMesh.mColors[pInput.mIndex].end(),
+                        pMesh.mPositions.size() - pMesh.mColors[pInput.mIndex].size() - 1, aiColor4D(0, 0, 0, 1));
+
+            aiColor4D result(0, 0, 0, 1);
+            for (size_t i = 0; i < pInput.mResolved->mSize; ++i) {
+                result[static_cast<unsigned int>(i)] = obj[pInput.mResolved->mSubOffset[i]];
+            }
+            pMesh.mColors[pInput.mIndex].push_back(result);
+        } else {
+            ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping.");
+        }
+
+        break;
+    default:
+        // IT_Invalid and IT_Vertex
+        ai_assert(false && "shouldn't ever get here");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the library of node hierarchies and scene parts
+void ColladaParser::ReadSceneLibrary(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "visual_scene") {
+            // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then?
+            std::string id;
+            XmlParser::getStdStrAttribute(currentNode, "id", id);
+
+            // read name if given.
+            std::string attrName = "Scene";
+            if (XmlParser::hasAttribute(currentNode, "name")) {
+                XmlParser::getStdStrAttribute(currentNode, "name", attrName);
+            }
+
+            // create a node and store it in the library under its ID
+            Node *sceneNode = new Node;
+            sceneNode->mID = id;
+            sceneNode->mName = attrName;
+            mNodeLibrary[sceneNode->mID] = sceneNode;
+
+            ReadSceneNode(currentNode, sceneNode);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a scene node's contents including children and stores it in the given node
+void ColladaParser::ReadSceneNode(XmlNode &node, Node *pNode) {
+    // quit immediately on <bla/> elements
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "node") {
+            Node *child = new Node;
+            if (XmlParser::hasAttribute(currentNode, "id")) {
+                XmlParser::getStdStrAttribute(currentNode, "id", child->mID);
+            }
+            if (XmlParser::hasAttribute(currentNode, "sid")) {
+                XmlParser::getStdStrAttribute(currentNode, "id", child->mSID);
+            }
+            if (XmlParser::hasAttribute(currentNode, "name")) {
+                XmlParser::getStdStrAttribute(currentNode, "name", child->mName);
+            }
+            if (pNode) {
+                pNode->mChildren.push_back(child);
+                child->mParent = pNode;
+            } else {
+                // no parent node given, probably called from <library_nodes> element.
+                // create new node in node library
+                mNodeLibrary[child->mID] = child;
+            }
+
+            // read on recursively from there
+            ReadSceneNode(currentNode, child);
+            continue;
+        } else if (!pNode) {
+            // For any further stuff we need a valid node to work on
+            continue;
+        }
+        if (currentName == "lookat") {
+            ReadNodeTransformation(currentNode, pNode, TF_LOOKAT);
+        } else if (currentName == "matrix") {
+            ReadNodeTransformation(currentNode, pNode, TF_MATRIX);
+        } else if (currentName == "rotate") {
+            ReadNodeTransformation(currentNode, pNode, TF_ROTATE);
+        } else if (currentName == "scale") {
+            ReadNodeTransformation(currentNode, pNode, TF_SCALE);
+        } else if (currentName == "skew") {
+            ReadNodeTransformation(currentNode, pNode, TF_SKEW);
+        } else if (currentName == "translate") {
+            ReadNodeTransformation(currentNode, pNode, TF_TRANSLATE);
+        } else if (currentName == "render" && pNode->mParent == nullptr && 0 == pNode->mPrimaryCamera.length()) {
+            // ... scene evaluation or, in other words, postprocessing pipeline,
+            // or, again in other words, a turing-complete description how to
+            // render a Collada scene. The only thing that is interesting for
+            // us is the primary camera.
+            if (XmlParser::hasAttribute(currentNode, "camera_node")) {
+                std::string s;
+                XmlParser::getStdStrAttribute(currentNode, "camera_node", s);
+                if (s[0] != '#') {
+                    ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera");
+                } else {
+                    pNode->mPrimaryCamera = s.c_str() + 1;
+                }
+            }
+        } else if (currentName == "instance_node") {
+            // find the node in the library
+            if (XmlParser::hasAttribute(currentNode, "url")) {
+                std::string s;
+                XmlParser::getStdStrAttribute(currentNode, "url", s);
+                if (s[0] != '#') {
+                    ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node");
+                } else {
+                    pNode->mNodeInstances.push_back(NodeInstance());
+                    pNode->mNodeInstances.back().mNode = s.c_str() + 1;
+                }
+            }
+        } else if (currentName == "instance_geometry" || currentName == "instance_controller") {
+            // Reference to a mesh or controller, with possible material associations
+            ReadNodeGeometry(currentNode, pNode);
+        } else if (currentName == "instance_light") {
+            // Reference to a light, name given in 'url' attribute
+            if (XmlParser::hasAttribute(currentNode, "url")) {
+                std::string url;
+                XmlParser::getStdStrAttribute(currentNode, "url", url);
+                if (url[0] != '#') {
+                    throw DeadlyImportError("Unknown reference format in <instance_light> element");
+                }
+
+                pNode->mLights.push_back(LightInstance());
+                pNode->mLights.back().mLight = url.c_str() + 1;
+            }
+        } else if (currentName == "instance_camera") {
+            // Reference to a camera, name given in 'url' attribute
+            if (XmlParser::hasAttribute(currentNode, "url")) {
+                std::string url;
+                XmlParser::getStdStrAttribute(currentNode, "url", url);
+                if (url[0] != '#') {
+                    throw DeadlyImportError("Unknown reference format in <instance_camera> element");
+                }
+                pNode->mCameras.push_back(CameraInstance());
+                pNode->mCameras.back().mCamera = url.c_str() + 1;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a node transformation entry of the given type and adds it to the given node's transformation list.
+void ColladaParser::ReadNodeTransformation(XmlNode &node, Node *pNode, TransformType pType) {
+    if (node.empty()) {
+        return;
+    }
+
+    std::string tagName = node.name();
+
+    Transform tf;
+    tf.mType = pType;
+
+    // read SID
+    if (XmlParser::hasAttribute(node, "sid")) {
+        XmlParser::getStdStrAttribute(node, "sid", tf.mID);
+    }
+
+    // how many parameters to read per transformation type
+    static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 };
+    std::string value;
+    XmlParser::getValueAsString(node, value);
+    const char *content = value.c_str();
+
+    // read as many parameters and store in the transformation
+    for (unsigned int a = 0; a < sNumParameters[pType]; a++) {
+        // skip whitespace before the number
+        SkipSpacesAndLineEnd(&content);
+        // read a number
+        content = fast_atoreal_move<ai_real>(content, tf.f[a]);
+    }
+
+    // place the transformation at the queue of the node
+    pNode->mTransforms.push_back(tf);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Processes bind_vertex_input and bind elements
+void ColladaParser::ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl) {
+    std::string name = node.name();
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "bind_vertex_input") {
+            Collada::InputSemanticMapEntry vn;
+
+            // effect semantic
+            if (XmlParser::hasAttribute(currentNode, "semantic")) {
+                std::string s;
+                XmlParser::getStdStrAttribute(currentNode, "semantic", s);
+                XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType);
+            }
+            std::string s;
+            XmlParser::getStdStrAttribute(currentNode, "semantic", s);
+
+            // input semantic
+            XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType);
+
+            // index of input set
+            if (XmlParser::hasAttribute(currentNode, "input_set")) {
+                XmlParser::getUIntAttribute(currentNode, "input_set", vn.mSet);
+            }
+
+            tbl.mMap[s] = vn;
+        } else if (currentName == "bind") {
+            ASSIMP_LOG_WARN("Collada: Found unsupported <bind> element");
+        }
+    }
+}
+
+void ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive) {
+    // Attempt to load any undefined Collada::Image in ImageLibrary
+    for (auto &it : mImageLibrary) {
+        Collada::Image &image = it.second;
+
+        if (image.mImageData.empty()) {
+            std::unique_ptr<IOStream> image_file(zip_archive.Open(image.mFileName.c_str()));
+            if (image_file) {
+                image.mImageData.resize(image_file->FileSize());
+                image_file->Read(image.mImageData.data(), image_file->FileSize(), 1);
+                image.mEmbeddedFormat = BaseImporter::GetExtension(image.mFileName);
+                if (image.mEmbeddedFormat == "jpeg") {
+                    image.mEmbeddedFormat = "jpg";
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a mesh reference in a node and adds it to the node's mesh list
+void ColladaParser::ReadNodeGeometry(XmlNode &node, Node *pNode) {
+    // referred mesh is given as an attribute of the <instance_geometry> element
+    std::string url;
+    XmlParser::getStdStrAttribute(node, "url", url);
+    if (url[0] != '#') {
+        throw DeadlyImportError("Unknown reference format");
+    }
+
+    Collada::MeshInstance instance;
+    instance.mMeshOrController = url.c_str() + 1; // skipping the leading #
+
+    for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "bind_material") {
+            XmlNode techNode = currentNode.child("technique_common");
+            if (techNode) {
+                for (XmlNode instanceMatNode = techNode.child("instance_material"); instanceMatNode; instanceMatNode = instanceMatNode.next_sibling())
+                {
+                    const std::string &instance_name = instanceMatNode.name();
+                    if (instance_name == "instance_material")
+                    {
+                        // read ID of the geometry subgroup and the target material
+                        std::string group;
+                        XmlParser::getStdStrAttribute(instanceMatNode, "symbol", group);
+                        XmlParser::getStdStrAttribute(instanceMatNode, "target", url);
+                        const char *urlMat = url.c_str();
+                        Collada::SemanticMappingTable s;
+                        if (urlMat[0] == '#')
+                            urlMat++;
+
+                        s.mMatName = urlMat;
+                        // store the association
+                        instance.mMaterials[group] = s;
+                        ReadMaterialVertexInputBinding(instanceMatNode, s);
+                    }
+                }
+            }
+        }
+    }
+
+    // store it
+    pNode->mMeshes.push_back(instance);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the collada scene
+void ColladaParser::ReadScene(XmlNode &node) {
+    if (node.empty()) {
+        return;
+    }
+
+    for (XmlNode &currentNode : node.children()) {
+        const std::string &currentName = currentNode.name();
+        if (currentName == "instance_visual_scene") {
+            // should be the first and only occurrence
+            if (mRootNode) {
+                throw DeadlyImportError("Invalid scene containing multiple root nodes in <instance_visual_scene> element");
+            }
+
+            // read the url of the scene to instance. Should be of format "#some_name"
+            std::string url;
+            XmlParser::getStdStrAttribute(currentNode, "url", url);
+            if (url[0] != '#') {
+                throw DeadlyImportError("Unknown reference format in <instance_visual_scene> element");
+            }
+
+            // find the referred scene, skip the leading #
+            NodeLibrary::const_iterator sit = mNodeLibrary.find(url.c_str() + 1);
+            if (sit == mNodeLibrary.end()) {
+                throw DeadlyImportError("Unable to resolve visual_scene reference \"", std::string(url), "\" in <instance_visual_scene> element.");
+            }
+            mRootNode = sit->second;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Calculates the resulting transformation from all the given transform steps
+aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector<Transform> &pTransforms) const {
+    aiMatrix4x4 res;
+
+    for (std::vector<Transform>::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it) {
+        const Transform &tf = *it;
+        switch (tf.mType) {
+        case TF_LOOKAT: {
+            aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]);
+            aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]);
+            aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize();
+            aiVector3D dir = aiVector3D(dstPos - pos).Normalize();
+            aiVector3D right = (dir ^ up).Normalize();
+
+            res *= aiMatrix4x4(
+                    right.x, up.x, -dir.x, pos.x,
+                    right.y, up.y, -dir.y, pos.y,
+                    right.z, up.z, -dir.z, pos.z,
+                    0, 0, 0, 1);
+            break;
+        }
+        case TF_ROTATE: {
+            aiMatrix4x4 rot;
+            ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0);
+            aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]);
+            aiMatrix4x4::Rotation(angle, axis, rot);
+            res *= rot;
+            break;
+        }
+        case TF_TRANSLATE: {
+            aiMatrix4x4 trans;
+            aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans);
+            res *= trans;
+            break;
+        }
+        case TF_SCALE: {
+            aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f,
+                    0.0f, 0.0f, 0.0f, 1.0f);
+            res *= scale;
+            break;
+        }
+        case TF_SKEW:
+            // TODO: (thom)
+            ai_assert(false);
+            break;
+        case TF_MATRIX: {
+            aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7],
+                    tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]);
+            res *= mat;
+            break;
+        }
+        default:
+            ai_assert(false);
+            break;
+        }
+    }
+
+    return res;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Determines the input data type for the given semantic string
+Collada::InputType ColladaParser::GetTypeForSemantic(const std::string &semantic) {
+    if (semantic.empty()) {
+        ASSIMP_LOG_WARN("Vertex input type is empty.");
+        return IT_Invalid;
+    }
+
+    if (semantic == "POSITION")
+        return IT_Position;
+    else if (semantic == "TEXCOORD")
+        return IT_Texcoord;
+    else if (semantic == "NORMAL")
+        return IT_Normal;
+    else if (semantic == "COLOR")
+        return IT_Color;
+    else if (semantic == "VERTEX")
+        return IT_Vertex;
+    else if (semantic == "BINORMAL" || semantic == "TEXBINORMAL")
+        return IT_Bitangent;
+    else if (semantic == "TANGENT" || semantic == "TEXTANGENT")
+        return IT_Tangent;
+
+    ASSIMP_LOG_WARN("Unknown vertex input type \"", semantic, "\". Ignoring.");
+    return IT_Invalid;
+}
+
+#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER
diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h
new file mode 100644
index 0000000..1598293
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h
@@ -0,0 +1,348 @@
+/*
+ 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 ColladaParser.h
+ *  @brief Defines the parser helper class for the collada loader
+ */
+
+#pragma once
+#ifndef AI_COLLADAPARSER_H_INC
+#define AI_COLLADAPARSER_H_INC
+
+#include "ColladaHelper.h"
+#include <assimp/TinyFormatter.h>
+#include <assimp/ai_assert.h>
+#include <assimp/XmlParser.h>
+
+#include <map>
+
+namespace Assimp {
+
+class ZipArchiveIOSystem;
+
+// ------------------------------------------------------------------------------------------
+/** Parser helper class for the Collada loader.
+     *
+     *  Does all the XML reading and builds internal data structures from it,
+     *  but leaves the resolving of all the references to the loader.
+     */
+class ColladaParser {
+    friend class ColladaLoader;
+
+    /** Converts a path read from a collada file to the usual representation */
+    static void UriDecodePath(aiString &ss);
+
+protected:
+    /** Map for generic metadata as aiString */
+    typedef std::map<std::string, aiString> StringMetaData;
+
+    /** Constructor from XML file */
+    ColladaParser(IOSystem *pIOHandler, const std::string &pFile);
+
+    /** Destructor */
+    ~ColladaParser();
+
+    /** Attempts to read the ZAE manifest and returns the DAE to open */
+    static std::string ReadZaeManifest(ZipArchiveIOSystem &zip_archive);
+
+    /** Reads the contents of the file */
+    void ReadContents(XmlNode &node);
+
+    /** Reads the structure of the file */
+    void ReadStructure(XmlNode &node);
+
+    /** Reads asset information such as coordinate system information and legal blah */
+    void ReadAssetInfo(XmlNode &node);
+
+    /** Reads contributor information such as author and legal blah */
+    void ReadContributorInfo(XmlNode &node);
+
+    /** Reads generic metadata into provided map and renames keys for Assimp */
+    void ReadMetaDataItem(XmlNode &node, StringMetaData &metadata);
+
+    /** Reads the animation library */
+    void ReadAnimationLibrary(XmlNode &node);
+
+    /** Reads the animation clip library */
+    void ReadAnimationClipLibrary(XmlNode &node);
+
+    /** Unwrap controllers dependency hierarchy */
+    void PostProcessControllers();
+
+    /** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */
+    void PostProcessRootAnimations();
+
+    /** Reads an animation into the given parent structure */
+    void ReadAnimation(XmlNode &node, Collada::Animation *pParent);
+
+    /** Reads an animation sampler into the given anim channel */
+    void ReadAnimationSampler(XmlNode &node, Collada::AnimationChannel &pChannel);
+
+    /** Reads the skeleton controller library */
+    void ReadControllerLibrary(XmlNode &node);
+
+    /** Reads a controller into the given mesh structure */
+    void ReadController(XmlNode &node, Collada::Controller &pController);
+
+    /** Reads the joint definitions for the given controller */
+    void ReadControllerJoints(XmlNode &node, Collada::Controller &pController);
+
+    /** Reads the joint weights for the given controller */
+    void ReadControllerWeights(XmlNode &node, Collada::Controller &pController);
+
+    /** Reads the image library contents */
+    void ReadImageLibrary(XmlNode &node);
+
+    /** Reads an image entry into the given image */
+    void ReadImage(XmlNode &node, Collada::Image &pImage);
+
+    /** Reads the material library */
+    void ReadMaterialLibrary(XmlNode &node);
+
+    /** Reads a material entry into the given material */
+    void ReadMaterial(XmlNode &node, Collada::Material &pMaterial);
+
+    /** Reads the camera library */
+    void ReadCameraLibrary(XmlNode &node);
+
+    /** Reads a camera entry into the given camera */
+    void ReadCamera(XmlNode &node, Collada::Camera &pCamera);
+
+    /** Reads the light library */
+    void ReadLightLibrary(XmlNode &node);
+
+    /** Reads a light entry into the given light */
+    void ReadLight(XmlNode &node, Collada::Light &pLight);
+
+    /** Reads the effect library */
+    void ReadEffectLibrary(XmlNode &node);
+
+    /** Reads an effect entry into the given effect*/
+    void ReadEffect(XmlNode &node, Collada::Effect &pEffect);
+
+    /** Reads an COMMON effect profile */
+    void ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect);
+
+    /** Read sampler properties */
+    void ReadSamplerProperties(XmlNode &node, Collada::Sampler &pSampler);
+
+    /** Reads an effect entry containing a color or a texture defining that color */
+    void ReadEffectColor(XmlNode &node, aiColor4D &pColor, Collada::Sampler &pSampler);
+
+    /** Reads an effect entry containing a float */
+    void ReadEffectFloat(XmlNode &node, ai_real &pFloat);
+
+    /** Reads an effect parameter specification of any kind */
+    void ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam);
+
+    /** Reads the geometry library contents */
+    void ReadGeometryLibrary(XmlNode &node);
+
+    /** Reads a geometry from the geometry library. */
+    void ReadGeometry(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads a mesh from the geometry library */
+    void ReadMesh(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads a source element - a combination of raw data and an accessor defining
+         * things that should not be redefinable. Yes, that's another rant.
+         */
+    void ReadSource(XmlNode &node);
+
+    /** Reads a data array holding a number of elements, and stores it in the global library.
+         * Currently supported are array of floats and arrays of strings.
+         */
+    void ReadDataArray(XmlNode &node);
+
+    /** Reads an accessor and stores it in the global library under the given ID -
+         * accessors use the ID of the parent <source> element
+         */
+    void ReadAccessor(XmlNode &node, const std::string &pID);
+
+    /** Reads input declarations of per-vertex mesh data into the given mesh */
+    void ReadVertexData(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads input declarations of per-index mesh data into the given mesh */
+    void ReadIndexData(XmlNode &node, Collada::Mesh &pMesh);
+
+    /** Reads a single input channel element and stores it in the given array, if valid */
+    void ReadInputChannel(XmlNode &node, std::vector<Collada::InputChannel> &poChannels);
+
+    /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
+    size_t ReadPrimitives(XmlNode &node, Collada::Mesh &pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+            size_t pNumPrimitives, const std::vector<size_t> &pVCount, Collada::PrimitiveType pPrimType);
+
+    /** Copies the data for a single primitive into the mesh, based on the InputChannels */
+    void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
+            Collada::Mesh &pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+            size_t currentPrimitive, const std::vector<size_t> &indices);
+
+    /** Reads one triangle of a tristrip into the mesh */
+    void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh &pMesh,
+            std::vector<Collada::InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &indices);
+
+    /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
+    void ExtractDataObjectFromChannel(const Collada::InputChannel &pInput, size_t pLocalIndex, Collada::Mesh &pMesh);
+
+    /** Reads the library of node hierarchies and scene parts */
+    void ReadSceneLibrary(XmlNode &node);
+
+    /** Reads a scene node's contents including children and stores it in the given node */
+    void ReadSceneNode(XmlNode &node, Collada::Node *pNode);
+
+    /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
+    void ReadNodeTransformation(XmlNode &node, Collada::Node *pNode, Collada::TransformType pType);
+
+    /** Reads a mesh reference in a node and adds it to the node's mesh list */
+    void ReadNodeGeometry(XmlNode &node, Collada::Node *pNode);
+
+    /** Reads the collada scene */
+    void ReadScene(XmlNode &node);
+
+    // Processes bind_vertex_input and bind elements
+    void ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl);
+
+    /** Reads embedded textures from a ZAE archive*/
+    void ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive);
+
+protected:
+    /** Calculates the resulting transformation from all the given transform steps */
+    aiMatrix4x4 CalculateResultTransform(const std::vector<Collada::Transform> &pTransforms) const;
+
+    /** Determines the input data type for the given semantic string */
+    Collada::InputType GetTypeForSemantic(const std::string &pSemantic);
+
+    /** Finds the item in the given library by its reference, throws if not found */
+    template <typename Type>
+    const Type &ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const;
+
+protected:
+    // Filename, for a verbose error message
+    std::string mFileName;
+
+    // XML reader, member for everyday use
+    XmlParser mXmlParser;
+
+    /** All data arrays found in the file by ID. Might be referred to by actually
+         everyone. Collada, you are a steaming pile of indirection. */
+    using DataLibrary = std::map<std::string, Collada::Data> ;
+    DataLibrary mDataLibrary;
+
+    /** Same for accessors which define how the data in a data array is accessed. */
+    using AccessorLibrary = std::map<std::string, Collada::Accessor> ;
+    AccessorLibrary mAccessorLibrary;
+
+    /** Mesh library: mesh by ID */
+    using MeshLibrary = std::map<std::string, Collada::Mesh *>;
+    MeshLibrary mMeshLibrary;
+
+    /** node library: root node of the hierarchy part by ID */
+    using NodeLibrary = std::map<std::string, Collada::Node *>;
+    NodeLibrary mNodeLibrary;
+
+    /** Image library: stores texture properties by ID */
+    using ImageLibrary = std::map<std::string, Collada::Image> ;
+    ImageLibrary mImageLibrary;
+
+    /** Effect library: surface attributes by ID */
+    using EffectLibrary = std::map<std::string, Collada::Effect> ;
+    EffectLibrary mEffectLibrary;
+
+    /** Material library: surface material by ID */
+    using MaterialLibrary = std::map<std::string, Collada::Material> ;
+    MaterialLibrary mMaterialLibrary;
+
+    /** Light library: surface light by ID */
+    using LightLibrary = std::map<std::string, Collada::Light> ;
+    LightLibrary mLightLibrary;
+
+    /** Camera library: surface material by ID */
+    using CameraLibrary = std::map<std::string, Collada::Camera> ;
+    CameraLibrary mCameraLibrary;
+
+    /** Controller library: joint controllers by ID */
+    using ControllerLibrary = std::map<std::string, Collada::Controller> ;
+    ControllerLibrary mControllerLibrary;
+
+    /** Animation library: animation references by ID */
+    using AnimationLibrary = std::map<std::string, Collada::Animation *> ;
+    AnimationLibrary mAnimationLibrary;
+
+    /** Animation clip library: clip animation references by ID */
+    using AnimationClipLibrary = std::vector<std::pair<std::string, std::vector<std::string>>> ;
+    AnimationClipLibrary mAnimationClipLibrary;
+
+    /** Pointer to the root node. Don't delete, it just points to one of
+         the nodes in the node library. */
+    Collada::Node *mRootNode;
+
+    /** Root animation container */
+    Collada::Animation mAnims;
+
+    /** Size unit: how large compared to a meter */
+    ai_real mUnitSize;
+
+    /** Which is the up vector */
+    enum { UP_X,
+        UP_Y,
+        UP_Z } mUpDirection;
+
+    /** Asset metadata (global for scene) */
+    StringMetaData mAssetMetaData;
+
+    /** Collada file format version */
+    Collada::FormatVersion mFormat;
+};
+
+// ------------------------------------------------------------------------------------------------
+// Finds the item in the given library by its reference, throws if not found
+template <typename Type>
+const Type &ColladaParser::ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const {
+    typename std::map<std::string, Type>::const_iterator it = pLibrary.find(pURL);
+    if (it == pLibrary.end()) {
+        throw DeadlyImportError("Unable to resolve library reference \"", pURL, "\".");
+    }
+    return it->second;
+}
+
+} // end of namespace Assimp
+
+#endif // AI_COLLADAPARSER_H_INC