add assimp submodule

1 files changed, 1288 insertions, 0 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.cpp b/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.cpp
new file mode 100644
index 0000000..caa7089
--- /dev/null
+++ b/src/mesh/assimp-master/code/AssetLib/ASE/ASELoader.cpp
@@ -0,0 +1,1288 @@
+/*
+---------------------------------------------------------------------------
+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  ASELoader.cpp
+ *  @brief Implementation of the ASE importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_ASE_IMPORTER
+
+#ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
+
+// internal headers
+#include "ASELoader.h"
+#include "Common/TargetAnimation.h"
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/StringComparison.h>
+
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
+
+#include <memory>
+
+// utilities
+#include <assimp/fast_atof.h>
+
+using namespace Assimp;
+using namespace Assimp::ASE;
+
+static const aiImporterDesc desc = {
+    "ASE Importer",
+    "",
+    "",
+    "Similar to 3DS but text-encoded",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "ase ask"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+ASEImporter::ASEImporter() :
+        mParser(), mBuffer(), pcScene(), configRecomputeNormals(), noSkeletonMesh() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+ASEImporter::~ASEImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool ASEImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+    static const char *tokens[] = { "*3dsmax_asciiexport" };
+    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Loader meta information
+const aiImporterDesc *ASEImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup configuration options
+void ASEImporter::SetupProperties(const Importer *pImp) {
+    configRecomputeNormals = (pImp->GetPropertyInteger(
+                                      AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS, 1) ?
+                                      true :
+                                      false);
+
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void ASEImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
+
+    // Check whether we can read from the file
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open ASE file ", pFile, ".");
+    }
+
+    // Allocate storage and copy the contents of the file to a memory buffer
+    std::vector<char> mBuffer2;
+    TextFileToBuffer(file.get(), mBuffer2);
+
+    this->mBuffer = &mBuffer2[0];
+    this->pcScene = pScene;
+
+    // ------------------------------------------------------------------
+    // Guess the file format by looking at the extension
+    // ASC is considered to be the older format 110,
+    // ASE is the actual version 200 (that is currently written by max)
+    // ------------------------------------------------------------------
+    unsigned int defaultFormat;
+    std::string::size_type s = pFile.length() - 1;
+    switch (pFile.c_str()[s]) {
+
+    case 'C':
+    case 'c':
+        defaultFormat = AI_ASE_OLD_FILE_FORMAT;
+        break;
+    default:
+        defaultFormat = AI_ASE_NEW_FILE_FORMAT;
+    };
+
+    // Construct an ASE parser and parse the file
+    ASE::Parser parser(mBuffer, defaultFormat);
+    mParser = &parser;
+    mParser->Parse();
+
+    //------------------------------------------------------------------
+    // Check whether we god at least one mesh. If we did - generate
+    // materials and copy meshes.
+    // ------------------------------------------------------------------
+    if (!mParser->m_vMeshes.empty()) {
+
+        // If absolutely no material has been loaded from the file
+        // we need to generate a default material
+        GenerateDefaultMaterial();
+
+        // process all meshes
+        bool tookNormals = false;
+        std::vector<aiMesh *> avOutMeshes;
+        avOutMeshes.reserve(mParser->m_vMeshes.size() * 2);
+        for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {
+            if ((*i).bSkip) {
+                continue;
+            }
+            BuildUniqueRepresentation(*i);
+
+            // Need to generate proper vertex normals if necessary
+            if (GenerateNormals(*i)) {
+                tookNormals = true;
+            }
+
+            // Convert all meshes to aiMesh objects
+            ConvertMeshes(*i, avOutMeshes);
+        }
+        if (tookNormals) {
+            ASSIMP_LOG_DEBUG("ASE: Taking normals from the file. Use "
+                             "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "
+                             "experience problems");
+        }
+
+        // Now build the output mesh list. Remove dummies
+        pScene->mNumMeshes = (unsigned int)avOutMeshes.size();
+        aiMesh **pp = pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+        for (std::vector<aiMesh *>::const_iterator i = avOutMeshes.begin(); i != avOutMeshes.end(); ++i) {
+            if (!(*i)->mNumFaces) {
+                continue;
+            }
+            *pp++ = *i;
+        }
+        pScene->mNumMeshes = (unsigned int)(pp - pScene->mMeshes);
+
+        // Build final material indices (remove submaterials and setup
+        // the final list)
+        BuildMaterialIndices();
+    }
+
+    // ------------------------------------------------------------------
+    // Copy all scene graph nodes - lights, cameras, dummies and meshes
+    // into one huge list.
+    //------------------------------------------------------------------
+    std::vector<BaseNode *> nodes;
+    nodes.reserve(mParser->m_vMeshes.size() + mParser->m_vLights.size() + mParser->m_vCameras.size() + mParser->m_vDummies.size());
+
+    // Lights
+    for (auto &light : mParser->m_vLights)
+        nodes.push_back(&light);
+    // Cameras
+    for (auto &camera : mParser->m_vCameras)
+        nodes.push_back(&camera);
+    // Meshes
+    for (auto &mesh : mParser->m_vMeshes)
+        nodes.push_back(&mesh);
+    // Dummies
+    for (auto &dummy : mParser->m_vDummies)
+        nodes.push_back(&dummy);
+
+    // build the final node graph
+    BuildNodes(nodes);
+
+    // build output animations
+    BuildAnimations(nodes);
+
+    // build output cameras
+    BuildCameras();
+
+    // build output lights
+    BuildLights();
+
+    // ------------------------------------------------------------------
+    // If we have no meshes use the SkeletonMeshBuilder helper class
+    // to build a mesh for the animation skeleton
+    // FIXME: very strange results
+    // ------------------------------------------------------------------
+    if (!pScene->mNumMeshes) {
+        pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+        if (!noSkeletonMesh) {
+            SkeletonMeshBuilder skeleton(pScene);
+        }
+    }
+}
+// ------------------------------------------------------------------------------------------------
+void ASEImporter::GenerateDefaultMaterial() {
+    ai_assert(nullptr != mParser);
+
+    bool bHas = false;
+    for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {
+        if ((*i).bSkip) continue;
+        if (ASE::Face::DEFAULT_MATINDEX == (*i).iMaterialIndex) {
+            (*i).iMaterialIndex = (unsigned int)mParser->m_vMaterials.size();
+            bHas = true;
+        }
+    }
+    if (bHas || mParser->m_vMaterials.empty()) {
+        // add a simple material without submaterials to the parser's list
+        mParser->m_vMaterials.push_back(ASE::Material(AI_DEFAULT_MATERIAL_NAME));
+        ASE::Material &mat = mParser->m_vMaterials.back();
+
+        mat.mDiffuse = aiColor3D(0.6f, 0.6f, 0.6f);
+        mat.mSpecular = aiColor3D(1.0f, 1.0f, 1.0f);
+        mat.mAmbient = aiColor3D(0.05f, 0.05f, 0.05f);
+        mat.mShading = Discreet3DS::Gouraud;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ASEImporter::BuildAnimations(const std::vector<BaseNode *> &nodes) {
+    // check whether we have at least one mesh which has animations
+    std::vector<ASE::BaseNode *>::const_iterator i = nodes.begin();
+    unsigned int iNum = 0;
+    for (; i != nodes.end(); ++i) {
+
+        // TODO: Implement Bezier & TCB support
+        if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) {
+            ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
+                            "This is not supported.");
+        }
+        if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) {
+            ASSIMP_LOG_WARN("ASE: Rotation controller uses Bezier/TCB keys. "
+                            "This is not supported.");
+        }
+        if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) {
+            ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
+                            "This is not supported.");
+        }
+
+        // We compare against 1 here - firstly one key is not
+        // really an animation and secondly MAX writes dummies
+        // that represent the node transformation.
+        if ((*i)->mAnim.akeyPositions.size() > 1 || (*i)->mAnim.akeyRotations.size() > 1 || (*i)->mAnim.akeyScaling.size() > 1) {
+            ++iNum;
+        }
+        if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan((*i)->mTargetPosition.x)) {
+            ++iNum;
+        }
+    }
+    if (iNum) {
+        // Generate a new animation channel and setup everything for it
+        pcScene->mNumAnimations = 1;
+        pcScene->mAnimations = new aiAnimation *[1];
+        aiAnimation *pcAnim = pcScene->mAnimations[0] = new aiAnimation();
+        pcAnim->mNumChannels = iNum;
+        pcAnim->mChannels = new aiNodeAnim *[iNum];
+        pcAnim->mTicksPerSecond = mParser->iFrameSpeed * mParser->iTicksPerFrame;
+
+        iNum = 0;
+
+        // Now iterate through all meshes and collect all data we can find
+        for (i = nodes.begin(); i != nodes.end(); ++i) {
+
+            ASE::BaseNode *me = *i;
+            if (me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan(me->mTargetPosition.x)) {
+                // Generate an extra channel for the camera/light target.
+                // BuildNodes() does also generate an extra node, named
+                // <baseName>.Target.
+                aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
+                nd->mNodeName.Set(me->mName + ".Target");
+
+                // If there is no input position channel we will need
+                // to supply the default position from the node's
+                // local transformation matrix.
+                /*TargetAnimationHelper helper;
+                if (me->mAnim.akeyPositions.empty())
+                {
+                    aiMatrix4x4& mat = (*i)->mTransform;
+                    helper.SetFixedMainAnimationChannel(aiVector3D(
+                        mat.a4, mat.b4, mat.c4));
+                }
+                else helper.SetMainAnimationChannel (&me->mAnim.akeyPositions);
+                helper.SetTargetAnimationChannel (&me->mTargetAnim.akeyPositions);
+
+                helper.Process(&me->mTargetAnim.akeyPositions);*/
+
+                // Allocate the key array and fill it
+                nd->mNumPositionKeys = (unsigned int)me->mTargetAnim.akeyPositions.size();
+                nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
+
+                ::memcpy(nd->mPositionKeys, &me->mTargetAnim.akeyPositions[0],
+                        nd->mNumPositionKeys * sizeof(aiVectorKey));
+            }
+
+            if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1) {
+                // Begin a new node animation channel for this node
+                aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
+                nd->mNodeName.Set(me->mName);
+
+                // copy position keys
+                if (me->mAnim.akeyPositions.size() > 1) {
+                    // Allocate the key array and fill it
+                    nd->mNumPositionKeys = (unsigned int)me->mAnim.akeyPositions.size();
+                    nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
+
+                    ::memcpy(nd->mPositionKeys, &me->mAnim.akeyPositions[0],
+                            nd->mNumPositionKeys * sizeof(aiVectorKey));
+                }
+                // copy rotation keys
+                if (me->mAnim.akeyRotations.size() > 1) {
+                    // Allocate the key array and fill it
+                    nd->mNumRotationKeys = (unsigned int)me->mAnim.akeyRotations.size();
+                    nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
+
+                    // --------------------------------------------------------------------
+                    // Rotation keys are offsets to the previous keys.
+                    // We have the quaternion representations of all
+                    // of them, so we just need to concatenate all
+                    // (unit-length) quaternions to get the absolute
+                    // rotations.
+                    // Rotation keys are ABSOLUTE for older files
+                    // --------------------------------------------------------------------
+
+                    aiQuaternion cur;
+                    for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) {
+                        aiQuatKey q = me->mAnim.akeyRotations[a];
+
+                        if (mParser->iFileFormat > 110) {
+                            cur = (a ? cur * q.mValue : q.mValue);
+                            q.mValue = cur.Normalize();
+                        }
+                        nd->mRotationKeys[a] = q;
+
+                        // need this to get to Assimp quaternion conventions
+                        nd->mRotationKeys[a].mValue.w *= -1.f;
+                    }
+                }
+                // copy scaling keys
+                if (me->mAnim.akeyScaling.size() > 1) {
+                    // Allocate the key array and fill it
+                    nd->mNumScalingKeys = (unsigned int)me->mAnim.akeyScaling.size();
+                    nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
+
+                    ::memcpy(nd->mScalingKeys, &me->mAnim.akeyScaling[0],
+                            nd->mNumScalingKeys * sizeof(aiVectorKey));
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build output cameras
+void ASEImporter::BuildCameras() {
+    if (!mParser->m_vCameras.empty()) {
+        pcScene->mNumCameras = (unsigned int)mParser->m_vCameras.size();
+        pcScene->mCameras = new aiCamera *[pcScene->mNumCameras];
+
+        for (unsigned int i = 0; i < pcScene->mNumCameras; ++i) {
+            aiCamera *out = pcScene->mCameras[i] = new aiCamera();
+            ASE::Camera &in = mParser->m_vCameras[i];
+
+            // copy members
+            out->mClipPlaneFar = in.mFar;
+            out->mClipPlaneNear = (in.mNear ? in.mNear : 0.1f);
+            out->mHorizontalFOV = in.mFOV;
+
+            out->mName.Set(in.mName);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build output lights
+void ASEImporter::BuildLights() {
+    if (!mParser->m_vLights.empty()) {
+        pcScene->mNumLights = (unsigned int)mParser->m_vLights.size();
+        pcScene->mLights = new aiLight *[pcScene->mNumLights];
+
+        for (unsigned int i = 0; i < pcScene->mNumLights; ++i) {
+            aiLight *out = pcScene->mLights[i] = new aiLight();
+            ASE::Light &in = mParser->m_vLights[i];
+
+            // The direction is encoded in the transformation matrix of the node.
+            // In 3DS MAX the light source points into negative Z direction if
+            // the node transformation is the identity.
+            out->mDirection = aiVector3D(0.f, 0.f, -1.f);
+
+            out->mName.Set(in.mName);
+            switch (in.mLightType) {
+            case ASE::Light::TARGET:
+                out->mType = aiLightSource_SPOT;
+                out->mAngleInnerCone = AI_DEG_TO_RAD(in.mAngle);
+                out->mAngleOuterCone = (in.mFalloff ? AI_DEG_TO_RAD(in.mFalloff) : out->mAngleInnerCone);
+                break;
+
+            case ASE::Light::DIRECTIONAL:
+                out->mType = aiLightSource_DIRECTIONAL;
+                break;
+
+            default:
+                //case ASE::Light::OMNI:
+                out->mType = aiLightSource_POINT;
+                break;
+            };
+            out->mColorDiffuse = out->mColorSpecular = in.mColor * in.mIntensity;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
+        aiNode *pcParent, const char *szName) {
+    aiMatrix4x4 m;
+    AddNodes(nodes, pcParent, szName, m);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add meshes to a given node
+void ASEImporter::AddMeshes(const ASE::BaseNode *snode, aiNode *node) {
+    for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
+        // Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color)
+        const aiMesh *pcMesh = pcScene->mMeshes[i];
+        const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];
+
+        if (mesh == snode) {
+            ++node->mNumMeshes;
+        }
+    }
+
+    if (node->mNumMeshes) {
+        node->mMeshes = new unsigned int[node->mNumMeshes];
+        for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes; ++i) {
+
+            const aiMesh *pcMesh = pcScene->mMeshes[i];
+            const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];
+            if (mesh == snode) {
+                node->mMeshes[p++] = i;
+
+                // Transform all vertices of the mesh back into their local space ->
+                // at the moment they are pretransformed
+                aiMatrix4x4 m = mesh->mTransform;
+                m.Inverse();
+
+                aiVector3D *pvCurPtr = pcMesh->mVertices;
+                const aiVector3D *pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
+                while (pvCurPtr != pvEndPtr) {
+                    *pvCurPtr = m * (*pvCurPtr);
+                    pvCurPtr++;
+                }
+
+                // Do the same for the normal vectors, if we have them.
+                // As always, inverse transpose.
+                if (pcMesh->mNormals) {
+                    aiMatrix3x3 m3 = aiMatrix3x3(mesh->mTransform);
+                    m3.Transpose();
+
+                    pvCurPtr = pcMesh->mNormals;
+                    pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
+                    while (pvCurPtr != pvEndPtr) {
+                        *pvCurPtr = m3 * (*pvCurPtr);
+                        pvCurPtr++;
+                    }
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add child nodes to a given parent node
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
+        aiNode *pcParent, const char *szName,
+        const aiMatrix4x4 &mat) {
+    const size_t len = szName ? ::strlen(szName) : 0;
+    ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS);
+
+    // Receives child nodes for the pcParent node
+    std::vector<aiNode *> apcNodes;
+
+    // Now iterate through all nodes in the scene and search for one
+    // which has *us* as parent.
+    for (std::vector<BaseNode *>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
+        const BaseNode *snode = *it;
+        if (szName) {
+            if (len != snode->mParent.length() || ::strcmp(szName, snode->mParent.c_str()))
+                continue;
+        } else if (snode->mParent.length())
+            continue;
+
+        (*it)->mProcessed = true;
+
+        // Allocate a new node and add it to the output data structure
+        apcNodes.push_back(new aiNode());
+        aiNode *node = apcNodes.back();
+
+        node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node"));
+        node->mParent = pcParent;
+
+        // Setup the transformation matrix of the node
+        aiMatrix4x4 mParentAdjust = mat;
+        mParentAdjust.Inverse();
+        node->mTransformation = mParentAdjust * snode->mTransform;
+
+        // Add sub nodes - prevent stack overflow due to recursive parenting
+        if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) {
+            AddNodes(nodes, node, node->mName.data, snode->mTransform);
+        }
+
+        // Further processing depends on the type of the node
+        if (snode->mType == ASE::BaseNode::Mesh) {
+            // If the type of this node is "Mesh" we need to search
+            // the list of output meshes in the data structure for
+            // all those that belonged to this node once. This is
+            // slightly inconvinient here and a better solution should
+            // be used when this code is refactored next.
+            AddMeshes(snode, node);
+        } else if (is_not_qnan(snode->mTargetPosition.x)) {
+            // If this is a target camera or light we generate a small
+            // child node which marks the position of the camera
+            // target (the direction information is contained in *this*
+            // node's animation track but the exact target position
+            // would be lost otherwise)
+            if (!node->mNumChildren) {
+                node->mChildren = new aiNode *[1];
+            }
+
+            aiNode *nd = new aiNode();
+
+            nd->mName.Set(snode->mName + ".Target");
+
+            nd->mTransformation.a4 = snode->mTargetPosition.x - snode->mTransform.a4;
+            nd->mTransformation.b4 = snode->mTargetPosition.y - snode->mTransform.b4;
+            nd->mTransformation.c4 = snode->mTargetPosition.z - snode->mTransform.c4;
+
+            nd->mParent = node;
+
+            // The .Target node is always the first child node
+            for (unsigned int m = 0; m < node->mNumChildren; ++m)
+                node->mChildren[m + 1] = node->mChildren[m];
+
+            node->mChildren[0] = nd;
+            node->mNumChildren++;
+
+            // What we did is so great, it is at least worth a debug message
+            ASSIMP_LOG_VERBOSE_DEBUG("ASE: Generating separate target node (", snode->mName, ")");
+        }
+    }
+
+    // Allocate enough space for the child nodes
+    // We allocate one slot more  in case this is a target camera/light
+    pcParent->mNumChildren = (unsigned int)apcNodes.size();
+    if (pcParent->mNumChildren) {
+        pcParent->mChildren = new aiNode *[apcNodes.size() + 1 /* PLUS ONE !!! */];
+
+        // now build all nodes for our nice new children
+        for (unsigned int p = 0; p < apcNodes.size(); ++p)
+            pcParent->mChildren[p] = apcNodes[p];
+    }
+    return;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build the output node graph
+void ASEImporter::BuildNodes(std::vector<BaseNode *> &nodes) {
+    ai_assert(nullptr != pcScene);
+
+    // allocate the one and only root node
+    aiNode *root = pcScene->mRootNode = new aiNode();
+    root->mName.Set("<ASERoot>");
+
+    // Setup the coordinate system transformation
+    pcScene->mRootNode->mNumChildren = 1;
+    pcScene->mRootNode->mChildren = new aiNode *[1];
+    aiNode *ch = pcScene->mRootNode->mChildren[0] = new aiNode();
+    ch->mParent = root;
+
+    // Change the transformation matrix of all nodes
+    for (BaseNode *node : nodes) {
+        aiMatrix4x4 &m = node->mTransform;
+        m.Transpose(); // row-order vs column-order
+    }
+
+    // add all nodes
+    AddNodes(nodes, ch, nullptr);
+
+    // now iterate through al nodes and find those that have not yet
+    // been added to the nodegraph (= their parent could not be recognized)
+    std::vector<const BaseNode *> aiList;
+    for (std::vector<BaseNode *>::iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
+        if ((*it)->mProcessed) {
+            continue;
+        }
+
+        // check whether our parent is known
+        bool bKnowParent = false;
+
+        // search the list another time, starting *here* and try to find out whether
+        // there is a node that references *us* as a parent
+        for (std::vector<BaseNode *>::const_iterator it2 = nodes.begin(); it2 != end; ++it2) {
+            if (it2 == it) {
+                continue;
+            }
+
+            if ((*it2)->mName == (*it)->mParent) {
+                bKnowParent = true;
+                break;
+            }
+        }
+        if (!bKnowParent) {
+            aiList.push_back(*it);
+        }
+    }
+
+    // Are there any orphaned nodes?
+    if (!aiList.empty()) {
+        std::vector<aiNode *> apcNodes;
+        apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren);
+
+        for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren; ++i)
+            apcNodes.push_back(pcScene->mRootNode->mChildren[i]);
+
+        delete[] pcScene->mRootNode->mChildren;
+        for (std::vector<const BaseNode *>::/*const_*/ iterator i = aiList.begin(); i != aiList.end(); ++i) {
+            const ASE::BaseNode *src = *i;
+
+            // The parent is not known, so we can assume that we must add
+            // this node to the root node of the whole scene
+            aiNode *pcNode = new aiNode();
+            pcNode->mParent = pcScene->mRootNode;
+            pcNode->mName.Set(src->mName);
+            AddMeshes(src, pcNode);
+            AddNodes(nodes, pcNode, pcNode->mName.data);
+            apcNodes.push_back(pcNode);
+        }
+
+        // Regenerate our output array
+        pcScene->mRootNode->mChildren = new aiNode *[apcNodes.size()];
+        for (unsigned int i = 0; i < apcNodes.size(); ++i)
+            pcScene->mRootNode->mChildren[i] = apcNodes[i];
+
+        pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size();
+    }
+
+    // Reset the third color set to nullptr - we used this field to store a temporary pointer
+    for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i)
+        pcScene->mMeshes[i]->mColors[2] = nullptr;
+
+    // The root node should not have at least one child or the file is valid
+    if (!pcScene->mRootNode->mNumChildren) {
+        throw DeadlyImportError("ASE: No nodes loaded. The file is either empty or corrupt");
+    }
+
+    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
+    pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert the imported data to the internal verbose representation
+void ASEImporter::BuildUniqueRepresentation(ASE::Mesh &mesh) {
+    // allocate output storage
+    std::vector<aiVector3D> mPositions;
+    std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+    std::vector<aiColor4D> mVertexColors;
+    std::vector<aiVector3D> mNormals;
+    std::vector<BoneVertex> mBoneVertices;
+
+    unsigned int iSize = (unsigned int)mesh.mFaces.size() * 3;
+    mPositions.resize(iSize);
+
+    // optional texture coordinates
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+        if (!mesh.amTexCoords[i].empty()) {
+            amTexCoords[i].resize(iSize);
+        }
+    }
+    // optional vertex colors
+    if (!mesh.mVertexColors.empty()) {
+        mVertexColors.resize(iSize);
+    }
+
+    // optional vertex normals (vertex normals can simply be copied)
+    if (!mesh.mNormals.empty()) {
+        mNormals.resize(iSize);
+    }
+    // bone vertices. There is no need to change the bone list
+    if (!mesh.mBoneVertices.empty()) {
+        mBoneVertices.resize(iSize);
+    }
+
+    // iterate through all faces in the mesh
+    unsigned int iCurrent = 0, fi = 0;
+    for (std::vector<ASE::Face>::iterator i = mesh.mFaces.begin(); i != mesh.mFaces.end(); ++i, ++fi) {
+        for (unsigned int n = 0; n < 3; ++n, ++iCurrent) {
+            mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]];
+
+            // add texture coordinates
+            for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+                if (mesh.amTexCoords[c].empty()) break;
+                amTexCoords[c][iCurrent] = mesh.amTexCoords[c][(*i).amUVIndices[c][n]];
+            }
+            // add vertex colors
+            if (!mesh.mVertexColors.empty()) {
+                mVertexColors[iCurrent] = mesh.mVertexColors[(*i).mColorIndices[n]];
+            }
+            // add normal vectors
+            if (!mesh.mNormals.empty()) {
+                mNormals[iCurrent] = mesh.mNormals[fi * 3 + n];
+                mNormals[iCurrent].Normalize();
+            }
+
+            // handle bone vertices
+            if ((*i).mIndices[n] < mesh.mBoneVertices.size()) {
+                // (sometimes this will cause bone verts to be duplicated
+                //  however, I' quite sure Schrompf' JoinVerticesStep
+                //  will fix that again ...)
+                mBoneVertices[iCurrent] = mesh.mBoneVertices[(*i).mIndices[n]];
+            }
+            (*i).mIndices[n] = iCurrent;
+        }
+    }
+
+    // replace the old arrays
+    mesh.mNormals = mNormals;
+    mesh.mPositions = mPositions;
+    mesh.mVertexColors = mVertexColors;
+
+    for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c)
+        mesh.amTexCoords[c] = amTexCoords[c];
+}
+
+// ------------------------------------------------------------------------------------------------
+// Copy a texture from the ASE structs to the output material
+void CopyASETexture(aiMaterial &mat, ASE::Texture &texture, aiTextureType type) {
+    // Setup the texture name
+    aiString tex;
+    tex.Set(texture.mMapName);
+    mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));
+
+    // Setup the texture blend factor
+    if (is_not_qnan(texture.mTextureBlend))
+        mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));
+
+    // Setup texture UV transformations
+    mat.AddProperty<ai_real>(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert from ASE material to output material
+void ASEImporter::ConvertMaterial(ASE::Material &mat) {
+    // LARGE TODO: Much code her is copied from 3DS ... join them maybe?
+
+    // Allocate the output material
+    mat.pcInstance = new aiMaterial();
+
+    // At first add the base ambient color of the
+    // scene to the material
+    mat.mAmbient.r += mParser->m_clrAmbient.r;
+    mat.mAmbient.g += mParser->m_clrAmbient.g;
+    mat.mAmbient.b += mParser->m_clrAmbient.b;
+
+    aiString name;
+    name.Set(mat.mName);
+    mat.pcInstance->AddProperty(&name, AI_MATKEY_NAME);
+
+    // material colors
+    mat.pcInstance->AddProperty(&mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
+    mat.pcInstance->AddProperty(&mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mat.pcInstance->AddProperty(&mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
+    mat.pcInstance->AddProperty(&mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+
+    // shininess
+    if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength) {
+        mat.pcInstance->AddProperty(&mat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
+        mat.pcInstance->AddProperty(&mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
+    }
+    // If there is no shininess, we can disable phong lighting
+    else if (D3DS::Discreet3DS::Metal == mat.mShading ||
+             D3DS::Discreet3DS::Phong == mat.mShading ||
+             D3DS::Discreet3DS::Blinn == mat.mShading) {
+        mat.mShading = D3DS::Discreet3DS::Gouraud;
+    }
+
+    // opacity
+    mat.pcInstance->AddProperty<ai_real>(&mat.mTransparency, 1, AI_MATKEY_OPACITY);
+
+    // Two sided rendering?
+    if (mat.mTwoSided) {
+        int i = 1;
+        mat.pcInstance->AddProperty<int>(&i, 1, AI_MATKEY_TWOSIDED);
+    }
+
+    // shading mode
+    aiShadingMode eShading = aiShadingMode_NoShading;
+    switch (mat.mShading) {
+    case D3DS::Discreet3DS::Flat:
+        eShading = aiShadingMode_Flat;
+        break;
+    case D3DS::Discreet3DS::Phong:
+        eShading = aiShadingMode_Phong;
+        break;
+    case D3DS::Discreet3DS::Blinn:
+        eShading = aiShadingMode_Blinn;
+        break;
+
+        // I don't know what "Wire" shading should be,
+        // assume it is simple lambertian diffuse (L dot N) shading
+    case D3DS::Discreet3DS::Wire: {
+        // set the wireframe flag
+        unsigned int iWire = 1;
+        mat.pcInstance->AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);
+    }
+    case D3DS::Discreet3DS::Gouraud:
+        eShading = aiShadingMode_Gouraud;
+        break;
+    case D3DS::Discreet3DS::Metal:
+        eShading = aiShadingMode_CookTorrance;
+        break;
+    }
+    mat.pcInstance->AddProperty<int>((int *)&eShading, 1, AI_MATKEY_SHADING_MODEL);
+
+    // DIFFUSE texture
+    if (mat.sTexDiffuse.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexDiffuse, aiTextureType_DIFFUSE);
+
+    // SPECULAR texture
+    if (mat.sTexSpecular.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexSpecular, aiTextureType_SPECULAR);
+
+    // AMBIENT texture
+    if (mat.sTexAmbient.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexAmbient, aiTextureType_AMBIENT);
+
+    // OPACITY texture
+    if (mat.sTexOpacity.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexOpacity, aiTextureType_OPACITY);
+
+    // EMISSIVE texture
+    if (mat.sTexEmissive.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexEmissive, aiTextureType_EMISSIVE);
+
+    // BUMP texture
+    if (mat.sTexBump.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexBump, aiTextureType_HEIGHT);
+
+    // SHININESS texture
+    if (mat.sTexShininess.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexShininess, aiTextureType_SHININESS);
+
+    // store the name of the material itself, too
+    if (mat.mName.length() > 0) {
+        aiString tex;
+        tex.Set(mat.mName);
+        mat.pcInstance->AddProperty(&tex, AI_MATKEY_NAME);
+    }
+    return;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build output meshes
+void ASEImporter::ConvertMeshes(ASE::Mesh &mesh, std::vector<aiMesh *> &avOutMeshes) {
+    // validate the material index of the mesh
+    if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) {
+        mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size() - 1;
+        ASSIMP_LOG_WARN("Material index is out of range");
+    }
+
+    // If the material the mesh is assigned to is consisting of submeshes, split it
+    if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) {
+        std::vector<ASE::Material> vSubMaterials = mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials;
+
+        std::vector<unsigned int> *aiSplit = new std::vector<unsigned int>[vSubMaterials.size()];
+
+        // build a list of all faces per sub-material
+        for (unsigned int i = 0; i < mesh.mFaces.size(); ++i) {
+            // check range
+            if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) {
+                ASSIMP_LOG_WARN("Submaterial index is out of range");
+
+                // use the last material instead
+                aiSplit[vSubMaterials.size() - 1].push_back(i);
+            } else
+                aiSplit[mesh.mFaces[i].iMaterial].push_back(i);
+        }
+
+        // now generate submeshes
+        for (unsigned int p = 0; p < vSubMaterials.size(); ++p) {
+            if (!aiSplit[p].empty()) {
+
+                aiMesh *p_pcOut = new aiMesh();
+                p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+                // let the sub material index
+                p_pcOut->mMaterialIndex = p;
+
+                // we will need this material
+                mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials[p].bNeed = true;
+
+                // store the real index here ... color channel 3
+                p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;
+
+                // store a pointer to the mesh in color channel 2
+                p_pcOut->mColors[2] = (aiColor4D *)&mesh;
+                avOutMeshes.push_back(p_pcOut);
+
+                // convert vertices
+                p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size() * 3;
+                p_pcOut->mNumFaces = (unsigned int)aiSplit[p].size();
+
+                // receive output vertex weights
+                std::vector<std::pair<unsigned int, float>> *avOutputBones = nullptr;
+                if (!mesh.mBones.empty()) {
+                    avOutputBones = new std::vector<std::pair<unsigned int, float>>[mesh.mBones.size()];
+                }
+
+                // allocate enough storage for faces
+                p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces];
+
+                unsigned int iBase = 0, iIndex;
+                if (p_pcOut->mNumVertices) {
+                    p_pcOut->mVertices = new aiVector3D[p_pcOut->mNumVertices];
+                    p_pcOut->mNormals = new aiVector3D[p_pcOut->mNumVertices];
+                    for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
+
+                        iIndex = aiSplit[p][q];
+
+                        p_pcOut->mFaces[q].mIndices = new unsigned int[3];
+                        p_pcOut->mFaces[q].mNumIndices = 3;
+
+                        for (unsigned int t = 0; t < 3; ++t, ++iBase) {
+                            const uint32_t iIndex2 = mesh.mFaces[iIndex].mIndices[t];
+
+                            p_pcOut->mVertices[iBase] = mesh.mPositions[iIndex2];
+                            p_pcOut->mNormals[iBase] = mesh.mNormals[iIndex2];
+
+                            // convert bones, if existing
+                            if (!mesh.mBones.empty()) {
+                                ai_assert(avOutputBones);
+                                // check whether there is a vertex weight for this vertex index
+                                if (iIndex2 < mesh.mBoneVertices.size()) {
+
+                                    for (std::vector<std::pair<int, float>>::const_iterator
+                                                    blubb = mesh.mBoneVertices[iIndex2].mBoneWeights.begin();
+                                            blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end(); ++blubb) {
+
+                                        // NOTE: illegal cases have already been filtered out
+                                        avOutputBones[(*blubb).first].push_back(std::pair<unsigned int, float>(
+                                                iBase, (*blubb).second));
+                                    }
+                                }
+                            }
+                            p_pcOut->mFaces[q].mIndices[t] = iBase;
+                        }
+                    }
+                }
+                // convert texture coordinates (up to AI_MAX_NUMBER_OF_TEXTURECOORDS sets supported)
+                for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+                    if (!mesh.amTexCoords[c].empty()) {
+                        p_pcOut->mTextureCoords[c] = new aiVector3D[p_pcOut->mNumVertices];
+                        iBase = 0;
+                        for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
+                            iIndex = aiSplit[p][q];
+                            for (unsigned int t = 0; t < 3; ++t) {
+                                p_pcOut->mTextureCoords[c][iBase++] = mesh.amTexCoords[c][mesh.mFaces[iIndex].mIndices[t]];
+                            }
+                        }
+                        // Setup the number of valid vertex components
+                        p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c];
+                    }
+                }
+
+                // Convert vertex colors (only one set supported)
+                if (!mesh.mVertexColors.empty()) {
+                    p_pcOut->mColors[0] = new aiColor4D[p_pcOut->mNumVertices];
+                    iBase = 0;
+                    for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
+                        iIndex = aiSplit[p][q];
+                        for (unsigned int t = 0; t < 3; ++t) {
+                            p_pcOut->mColors[0][iBase++] = mesh.mVertexColors[mesh.mFaces[iIndex].mIndices[t]];
+                        }
+                    }
+                }
+                // Copy bones
+                if (!mesh.mBones.empty()) {
+                    p_pcOut->mNumBones = 0;
+                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock)
+                        if (!avOutputBones[mrspock].empty()) p_pcOut->mNumBones++;
+
+                    p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones];
+                    aiBone **pcBone = p_pcOut->mBones;
+                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock) {
+                        if (!avOutputBones[mrspock].empty()) {
+                            // we will need this bone. add it to the output mesh and
+                            // add all per-vertex weights
+                            aiBone *pc = *pcBone = new aiBone();
+                            pc->mName.Set(mesh.mBones[mrspock].mName);
+
+                            pc->mNumWeights = (unsigned int)avOutputBones[mrspock].size();
+                            pc->mWeights = new aiVertexWeight[pc->mNumWeights];
+
+                            for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights; ++captainkirk) {
+                                const std::pair<unsigned int, float> &ref = avOutputBones[mrspock][captainkirk];
+                                pc->mWeights[captainkirk].mVertexId = ref.first;
+                                pc->mWeights[captainkirk].mWeight = ref.second;
+                            }
+                            ++pcBone;
+                        }
+                    }
+                    // delete allocated storage
+                    delete[] avOutputBones;
+                }
+            }
+        }
+        // delete storage
+        delete[] aiSplit;
+    } else {
+        // Otherwise we can simply copy the data to one output mesh
+        // This codepath needs less memory and uses fast memcpy()s
+        // to do the actual copying. So I think it is worth the
+        // effort here.
+
+        aiMesh *p_pcOut = new aiMesh();
+        p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+        // set an empty sub material index
+        p_pcOut->mMaterialIndex = ASE::Face::DEFAULT_MATINDEX;
+        mParser->m_vMaterials[mesh.iMaterialIndex].bNeed = true;
+
+        // store the real index here ... in color channel 3
+        p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;
+
+        // store a pointer to the mesh in color channel 2
+        p_pcOut->mColors[2] = (aiColor4D *)&mesh;
+        avOutMeshes.push_back(p_pcOut);
+
+        // If the mesh hasn't faces or vertices, there are two cases
+        // possible: 1. the model is invalid. 2. This is a dummy
+        // helper object which we are going to remove later ...
+        if (mesh.mFaces.empty() || mesh.mPositions.empty()) {
+            return;
+        }
+
+        // convert vertices
+        p_pcOut->mNumVertices = (unsigned int)mesh.mPositions.size();
+        p_pcOut->mNumFaces = (unsigned int)mesh.mFaces.size();
+
+        // allocate enough storage for faces
+        p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces];
+
+        // copy vertices
+        p_pcOut->mVertices = new aiVector3D[mesh.mPositions.size()];
+        memcpy(p_pcOut->mVertices, &mesh.mPositions[0],
+                mesh.mPositions.size() * sizeof(aiVector3D));
+
+        // copy normals
+        p_pcOut->mNormals = new aiVector3D[mesh.mNormals.size()];
+        memcpy(p_pcOut->mNormals, &mesh.mNormals[0],
+                mesh.mNormals.size() * sizeof(aiVector3D));
+
+        // copy texture coordinates
+        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+            if (!mesh.amTexCoords[c].empty()) {
+                p_pcOut->mTextureCoords[c] = new aiVector3D[mesh.amTexCoords[c].size()];
+                memcpy(p_pcOut->mTextureCoords[c], &mesh.amTexCoords[c][0],
+                        mesh.amTexCoords[c].size() * sizeof(aiVector3D));
+
+                // setup the number of valid vertex components
+                p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c];
+            }
+        }
+
+        // copy vertex colors
+        if (!mesh.mVertexColors.empty()) {
+            p_pcOut->mColors[0] = new aiColor4D[mesh.mVertexColors.size()];
+            memcpy(p_pcOut->mColors[0], &mesh.mVertexColors[0],
+                    mesh.mVertexColors.size() * sizeof(aiColor4D));
+        }
+
+        // copy faces
+        for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces; ++iFace) {
+            p_pcOut->mFaces[iFace].mNumIndices = 3;
+            p_pcOut->mFaces[iFace].mIndices = new unsigned int[3];
+
+            // copy indices
+            p_pcOut->mFaces[iFace].mIndices[0] = mesh.mFaces[iFace].mIndices[0];
+            p_pcOut->mFaces[iFace].mIndices[1] = mesh.mFaces[iFace].mIndices[1];
+            p_pcOut->mFaces[iFace].mIndices[2] = mesh.mFaces[iFace].mIndices[2];
+        }
+
+        // copy vertex bones
+        if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty()) {
+            std::vector<std::vector<aiVertexWeight>> avBonesOut(mesh.mBones.size());
+
+            // find all vertex weights for this bone
+            unsigned int quak = 0;
+            for (std::vector<BoneVertex>::const_iterator harrypotter = mesh.mBoneVertices.begin();
+                    harrypotter != mesh.mBoneVertices.end(); ++harrypotter, ++quak) {
+
+                for (std::vector<std::pair<int, float>>::const_iterator
+                                ronaldweasley = (*harrypotter).mBoneWeights.begin();
+                        ronaldweasley != (*harrypotter).mBoneWeights.end(); ++ronaldweasley) {
+                    aiVertexWeight weight;
+                    weight.mVertexId = quak;
+                    weight.mWeight = (*ronaldweasley).second;
+                    avBonesOut[(*ronaldweasley).first].push_back(weight);
+                }
+            }
+
+            // now build a final bone list
+            p_pcOut->mNumBones = 0;
+            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy)
+                if (!avBonesOut[jfkennedy].empty()) p_pcOut->mNumBones++;
+
+            p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones];
+            aiBone **pcBone = p_pcOut->mBones;
+            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy) {
+                if (!avBonesOut[jfkennedy].empty()) {
+                    aiBone *pc = *pcBone = new aiBone();
+                    pc->mName.Set(mesh.mBones[jfkennedy].mName);
+                    pc->mNumWeights = (unsigned int)avBonesOut[jfkennedy].size();
+                    pc->mWeights = new aiVertexWeight[pc->mNumWeights];
+                    ::memcpy(pc->mWeights, &avBonesOut[jfkennedy][0],
+                            sizeof(aiVertexWeight) * pc->mNumWeights);
+                    ++pcBone;
+                }
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Setup proper material indices and build output materials
+void ASEImporter::BuildMaterialIndices() {
+    ai_assert(nullptr != pcScene);
+
+    // iterate through all materials and check whether we need them
+    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) {
+        ASE::Material &mat = mParser->m_vMaterials[iMat];
+        if (mat.bNeed) {
+            // Convert it to the aiMaterial layout
+            ConvertMaterial(mat);
+            ++pcScene->mNumMaterials;
+        }
+        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) {
+            ASE::Material &submat = mat.avSubMaterials[iSubMat];
+            if (submat.bNeed) {
+                // Convert it to the aiMaterial layout
+                ConvertMaterial(submat);
+                ++pcScene->mNumMaterials;
+            }
+        }
+    }
+
+    // allocate the output material array
+    pcScene->mMaterials = new aiMaterial *[pcScene->mNumMaterials];
+    D3DS::Material **pcIntMaterials = new D3DS::Material *[pcScene->mNumMaterials];
+
+    unsigned int iNum = 0;
+    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) {
+        ASE::Material &mat = mParser->m_vMaterials[iMat];
+        if (mat.bNeed) {
+            ai_assert(nullptr != mat.pcInstance);
+            pcScene->mMaterials[iNum] = mat.pcInstance;
+
+            // Store the internal material, too
+            pcIntMaterials[iNum] = &mat;
+
+            // Iterate through all meshes and search for one which is using
+            // this top-level material index
+            for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) {
+                aiMesh *mesh = pcScene->mMeshes[iMesh];
+                if (ASE::Face::DEFAULT_MATINDEX == mesh->mMaterialIndex &&
+                        iMat == (uintptr_t)mesh->mColors[3]) {
+                    mesh->mMaterialIndex = iNum;
+                    mesh->mColors[3] = nullptr;
+                }
+            }
+            iNum++;
+        }
+        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) {
+            ASE::Material &submat = mat.avSubMaterials[iSubMat];
+            if (submat.bNeed) {
+                ai_assert(nullptr != submat.pcInstance);
+                pcScene->mMaterials[iNum] = submat.pcInstance;
+
+                // Store the internal material, too
+                pcIntMaterials[iNum] = &submat;
+
+                // Iterate through all meshes and search for one which is using
+                // this sub-level material index
+                for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) {
+                    aiMesh *mesh = pcScene->mMeshes[iMesh];
+
+                    if (iSubMat == mesh->mMaterialIndex && iMat == (uintptr_t)mesh->mColors[3]) {
+                        mesh->mMaterialIndex = iNum;
+                        mesh->mColors[3] = nullptr;
+                    }
+                }
+                iNum++;
+            }
+        }
+    }
+
+    // Delete our temporary array
+    delete[] pcIntMaterials;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Generate normal vectors basing on smoothing groups
+bool ASEImporter::GenerateNormals(ASE::Mesh &mesh) {
+
+    if (!mesh.mNormals.empty() && !configRecomputeNormals) {
+        // Check whether there are only uninitialized normals. If there are
+        // some, skip all normals from the file and compute them on our own
+        for (std::vector<aiVector3D>::const_iterator qq = mesh.mNormals.begin(); qq != mesh.mNormals.end(); ++qq) {
+            if ((*qq).x || (*qq).y || (*qq).z) {
+                return true;
+            }
+        }
+    }
+    // The array is reused.
+    ComputeNormalsWithSmoothingsGroups<ASE::Face>(mesh);
+    return false;
+}
+
+#endif // ASSIMP_BUILD_NO_3DS_IMPORTER
+
+#endif // !! ASSIMP_BUILD_NO_BASE_IMPORTER