move 3rd-party librarys into libs/ and add built-in honeysuckle

1 files changed, 1375 insertions, 0 deletions

diff --git a/libs/assimp/code/Common/SceneCombiner.cpp b/libs/assimp/code/Common/SceneCombiner.cpp
new file mode 100644
index 0000000..2c2539e
--- /dev/null
+++ b/libs/assimp/code/Common/SceneCombiner.cpp
@@ -0,0 +1,1375 @@
+/*
+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.
+
+----------------------------------------------------------------------
+*/
+
+// TODO: refactor entire file to get rid of the "flat-copy" first approach
+// to copying structures. This easily breaks in the most unintuitive way
+// possible as new fields are added to assimp structures.
+
+// ----------------------------------------------------------------------------
+/**
+  * @file Implements Assimp::SceneCombiner. This is a smart utility
+  *       class that combines multiple scenes, meshes, ... into one. Currently
+  *       these utilities are used by the IRR and LWS loaders and the
+  *       OptimizeGraph step.
+  */
+// ----------------------------------------------------------------------------
+#include "ScenePrivate.h"
+#include "time.h"
+#include <assimp/Hash.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/mesh.h>
+#include <assimp/metadata.h>
+#include <assimp/scene.h>
+#include <stdio.h>
+#include <assimp/DefaultLogger.hpp>
+
+namespace Assimp {
+
+#if (__GNUC__ >= 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wclass-memaccess"
+#endif
+
+// ------------------------------------------------------------------------------------------------
+// Add a prefix to a string
+inline void PrefixString(aiString &string, const char *prefix, unsigned int len) {
+    // If the string is already prefixed, we won't prefix it a second time
+    if (string.length >= 1 && string.data[0] == '$')
+        return;
+
+    if (len + string.length >= MAXLEN - 1) {
+        ASSIMP_LOG_VERBOSE_DEBUG("Can't add an unique prefix because the string is too long");
+        ai_assert(false);
+        return;
+    }
+
+    // Add the prefix
+    ::memmove(string.data + len, string.data, string.length + 1);
+    ::memcpy(string.data, prefix, len);
+
+    // And update the string's length
+    string.length += len;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add node identifiers to a hashing set
+void SceneCombiner::AddNodeHashes(aiNode *node, std::set<unsigned int> &hashes) {
+    // Add node name to hashing set if it is non-empty - empty nodes are allowed
+    // and they can't have any anims assigned so its absolutely safe to duplicate them.
+    if (node->mName.length) {
+        hashes.insert(SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length)));
+    }
+
+    // Process all children recursively
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        AddNodeHashes(node->mChildren[i], hashes);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add a name prefix to all nodes in a hierarchy
+void SceneCombiner::AddNodePrefixes(aiNode *node, const char *prefix, unsigned int len) {
+    ai_assert(nullptr != prefix);
+
+    PrefixString(node->mName, prefix, len);
+
+    // Process all children recursively
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        AddNodePrefixes(node->mChildren[i], prefix, len);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Search for matching names
+bool SceneCombiner::FindNameMatch(const aiString &name, std::vector<SceneHelper> &input, unsigned int cur) {
+    const unsigned int hash = SuperFastHash(name.data, static_cast<uint32_t>(name.length));
+
+    // Check whether we find a positive match in one of the given sets
+    for (unsigned int i = 0; i < input.size(); ++i) {
+        if (cur != i && input[i].hashes.find(hash) != input[i].hashes.end()) {
+            return true;
+        }
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add a name prefix to all nodes in a hierarchy if a hash match is found
+void SceneCombiner::AddNodePrefixesChecked(aiNode *node, const char *prefix, unsigned int len,
+        std::vector<SceneHelper> &input, unsigned int cur) {
+    ai_assert(nullptr != prefix);
+
+    const unsigned int hash = SuperFastHash(node->mName.data, static_cast<uint32_t>(node->mName.length));
+
+    // Check whether we find a positive match in one of the given sets
+    for (unsigned int i = 0; i < input.size(); ++i) {
+        if (cur != i && input[i].hashes.find(hash) != input[i].hashes.end()) {
+            PrefixString(node->mName, prefix, len);
+            break;
+        }
+    }
+
+    // Process all children recursively
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        AddNodePrefixesChecked(node->mChildren[i], prefix, len, input, cur);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Add an offset to all mesh indices in a node graph
+void SceneCombiner::OffsetNodeMeshIndices(aiNode *node, unsigned int offset) {
+    for (unsigned int i = 0; i < node->mNumMeshes; ++i)
+        node->mMeshes[i] += offset;
+
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        OffsetNodeMeshIndices(node->mChildren[i], offset);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Merges two scenes. Currently only used by the LWS loader.
+void SceneCombiner::MergeScenes(aiScene **_dest, std::vector<aiScene *> &src, unsigned int flags) {
+    if (nullptr == _dest) {
+        return;
+    }
+
+    // if _dest points to nullptr allocate a new scene. Otherwise clear the old and reuse it
+    if (src.empty()) {
+        if (*_dest) {
+            (*_dest)->~aiScene();
+            SceneCombiner::CopySceneFlat(_dest, src[0]);
+        } else
+            *_dest = src[0];
+        return;
+    }
+    if (*_dest) {
+        (*_dest)->~aiScene();
+        new (*_dest) aiScene();
+    } else
+        *_dest = new aiScene();
+
+    // Create a dummy scene to serve as master for the others
+    aiScene *master = new aiScene();
+    master->mRootNode = new aiNode();
+    master->mRootNode->mName.Set("<MergeRoot>");
+
+    std::vector<AttachmentInfo> srcList(src.size());
+    for (unsigned int i = 0; i < srcList.size(); ++i) {
+        srcList[i] = AttachmentInfo(src[i], master->mRootNode);
+    }
+
+    // 'master' will be deleted afterwards
+    MergeScenes(_dest, master, srcList, flags);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::AttachToGraph(aiNode *attach, std::vector<NodeAttachmentInfo> &srcList) {
+    unsigned int cnt;
+    for (cnt = 0; cnt < attach->mNumChildren; ++cnt) {
+        AttachToGraph(attach->mChildren[cnt], srcList);
+    }
+
+    cnt = 0;
+    for (std::vector<NodeAttachmentInfo>::iterator it = srcList.begin();
+            it != srcList.end(); ++it) {
+        if ((*it).attachToNode == attach && !(*it).resolved)
+            ++cnt;
+    }
+
+    if (cnt) {
+        aiNode **n = new aiNode *[cnt + attach->mNumChildren];
+        if (attach->mNumChildren) {
+            ::memcpy(n, attach->mChildren, sizeof(void *) * attach->mNumChildren);
+            delete[] attach->mChildren;
+        }
+        attach->mChildren = n;
+
+        n += attach->mNumChildren;
+        attach->mNumChildren += cnt;
+
+        for (unsigned int i = 0; i < srcList.size(); ++i) {
+            NodeAttachmentInfo &att = srcList[i];
+            if (att.attachToNode == attach && !att.resolved) {
+                *n = att.node;
+                (**n).mParent = attach;
+                ++n;
+
+                // mark this attachment as resolved
+                att.resolved = true;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::AttachToGraph(aiScene *master, std::vector<NodeAttachmentInfo> &src) {
+    ai_assert(nullptr != master);
+
+    AttachToGraph(master->mRootNode, src);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::MergeScenes(aiScene **_dest, aiScene *master, std::vector<AttachmentInfo> &srcList, unsigned int flags) {
+    if (nullptr == _dest) {
+        return;
+    }
+
+    // if _dest points to nullptr allocate a new scene. Otherwise clear the old and reuse it
+    if (srcList.empty()) {
+        if (*_dest) {
+            SceneCombiner::CopySceneFlat(_dest, master);
+        } else
+            *_dest = master;
+        return;
+    }
+    if (*_dest) {
+        (*_dest)->~aiScene();
+        new (*_dest) aiScene();
+    } else
+        *_dest = new aiScene();
+
+    aiScene *dest = *_dest;
+
+    std::vector<SceneHelper> src(srcList.size() + 1);
+    src[0].scene = master;
+    for (unsigned int i = 0; i < srcList.size(); ++i) {
+        src[i + 1] = SceneHelper(srcList[i].scene);
+    }
+
+    // this helper array specifies which scenes are duplicates of others
+    std::vector<unsigned int> duplicates(src.size(), UINT_MAX);
+
+    // this helper array is used as lookup table several times
+    std::vector<unsigned int> offset(src.size());
+
+    // Find duplicate scenes
+    for (unsigned int i = 0; i < src.size(); ++i) {
+        if (duplicates[i] != i && duplicates[i] != UINT_MAX) {
+            continue;
+        }
+
+        duplicates[i] = i;
+        for (unsigned int a = i + 1; a < src.size(); ++a) {
+            if (src[i].scene == src[a].scene) {
+                duplicates[a] = i;
+            }
+        }
+    }
+
+    // Generate unique names for all named stuff?
+    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
+#if 0
+        // Construct a proper random number generator
+        boost::mt19937 rng(  );
+        boost::uniform_int<> dist(1u,1 << 24u);
+        boost::variate_generator<boost::mt19937&, boost::uniform_int<> > rndGen(rng, dist);
+#endif
+        for (unsigned int i = 1; i < src.size(); ++i) {
+            //if (i != duplicates[i])
+            //{
+            //  // duplicate scenes share the same UID
+            //  ::strcpy( src[i].id, src[duplicates[i]].id );
+            //  src[i].idlen = src[duplicates[i]].idlen;
+
+            //  continue;
+            //}
+
+            src[i].idlen = ai_snprintf(src[i].id, 32, "$%.6X$_", i);
+
+            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+
+                // Compute hashes for all identifiers in this scene and store them
+                // in a sorted table (for convenience I'm using std::set). We hash
+                // just the node and animation channel names, all identifiers except
+                // the material names should be caught by doing this.
+                AddNodeHashes(src[i]->mRootNode, src[i].hashes);
+
+                for (unsigned int a = 0; a < src[i]->mNumAnimations; ++a) {
+                    aiAnimation *anim = src[i]->mAnimations[a];
+                    src[i].hashes.insert(SuperFastHash(anim->mName.data, static_cast<uint32_t>(anim->mName.length)));
+                }
+            }
+        }
+    }
+
+    unsigned int cnt;
+
+    // First find out how large the respective output arrays must be
+    for (unsigned int n = 0; n < src.size(); ++n) {
+        SceneHelper *cur = &src[n];
+
+        if (n == duplicates[n] || flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY) {
+            dest->mNumTextures += (*cur)->mNumTextures;
+            dest->mNumMaterials += (*cur)->mNumMaterials;
+            dest->mNumMeshes += (*cur)->mNumMeshes;
+        }
+
+        dest->mNumLights += (*cur)->mNumLights;
+        dest->mNumCameras += (*cur)->mNumCameras;
+        dest->mNumAnimations += (*cur)->mNumAnimations;
+
+        // Combine the flags of all scenes
+        // We need to process them flag-by-flag here to get correct results
+        // dest->mFlags ; //|= (*cur)->mFlags;
+        if ((*cur)->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
+            dest->mFlags |= AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
+        }
+    }
+
+    // generate the output texture list + an offset table for all texture indices
+    if (dest->mNumTextures) {
+        aiTexture **pip = dest->mTextures = new aiTexture *[dest->mNumTextures];
+        cnt = 0;
+        for (unsigned int n = 0; n < src.size(); ++n) {
+            SceneHelper *cur = &src[n];
+            for (unsigned int i = 0; i < (*cur)->mNumTextures; ++i) {
+                if (n != duplicates[n]) {
+                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
+                        Copy(pip, (*cur)->mTextures[i]);
+
+                    else
+                        continue;
+                } else
+                    *pip = (*cur)->mTextures[i];
+                ++pip;
+            }
+
+            offset[n] = cnt;
+            cnt = (unsigned int)(pip - dest->mTextures);
+        }
+    }
+
+    // generate the output material list + an offset table for all material indices
+    if (dest->mNumMaterials) {
+        aiMaterial **pip = dest->mMaterials = new aiMaterial *[dest->mNumMaterials];
+        cnt = 0;
+        for (unsigned int n = 0; n < src.size(); ++n) {
+            SceneHelper *cur = &src[n];
+            for (unsigned int i = 0; i < (*cur)->mNumMaterials; ++i) {
+                if (n != duplicates[n]) {
+                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
+                        Copy(pip, (*cur)->mMaterials[i]);
+
+                    else
+                        continue;
+                } else
+                    *pip = (*cur)->mMaterials[i];
+
+                if ((*cur)->mNumTextures != dest->mNumTextures) {
+                    // We need to update all texture indices of the mesh. So we need to search for
+                    // a material property called '$tex.file'
+
+                    for (unsigned int a = 0; a < (*pip)->mNumProperties; ++a) {
+                        aiMaterialProperty *prop = (*pip)->mProperties[a];
+                        if (!strncmp(prop->mKey.data, "$tex.file", 9)) {
+                            // Check whether this texture is an embedded texture.
+                            // In this case the property looks like this: *<n>,
+                            // where n is the index of the texture.
+                            // Copy here because we overwrite the string data in-place and the buffer inside of aiString
+                            // will be a lie if we just reinterpret from prop->mData. The size of mData is not guaranteed to be
+                            // MAXLEN in size.
+                            aiString s(*(aiString *)prop->mData);
+                            if ('*' == s.data[0]) {
+                                // Offset the index and write it back ..
+                                const unsigned int idx = strtoul10(&s.data[1]) + offset[n];
+                                const unsigned int oldLen = s.length;
+
+                                s.length = 1 + ASSIMP_itoa10(&s.data[1], sizeof(s.data) - 1, idx);
+
+                                // The string changed in size so we need to reallocate the buffer for the property.
+                                if (oldLen < s.length) {
+                                    prop->mDataLength += s.length - oldLen;
+                                    delete[] prop->mData;
+                                    prop->mData = new char[prop->mDataLength];
+                                }
+
+                                memcpy(prop->mData, static_cast<void*>(&s), prop->mDataLength);
+                            }
+                        }
+
+                        // Need to generate new, unique material names?
+                        else if (!::strcmp(prop->mKey.data, "$mat.name") && flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) {
+                            aiString *pcSrc = (aiString *)prop->mData;
+                            PrefixString(*pcSrc, (*cur).id, (*cur).idlen);
+                        }
+                    }
+                }
+                ++pip;
+            }
+
+            offset[n] = cnt;
+            cnt = (unsigned int)(pip - dest->mMaterials);
+        }
+    }
+
+    // generate the output mesh list + again an offset table for all mesh indices
+    if (dest->mNumMeshes) {
+        aiMesh **pip = dest->mMeshes = new aiMesh *[dest->mNumMeshes];
+        cnt = 0;
+        for (unsigned int n = 0; n < src.size(); ++n) {
+            SceneHelper *cur = &src[n];
+            for (unsigned int i = 0; i < (*cur)->mNumMeshes; ++i) {
+                if (n != duplicates[n]) {
+                    if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY)
+                        Copy(pip, (*cur)->mMeshes[i]);
+
+                    else
+                        continue;
+                } else
+                    *pip = (*cur)->mMeshes[i];
+
+                // update the material index of the mesh
+                (*pip)->mMaterialIndex += offset[n];
+                ++pip;
+            }
+
+            // reuse the offset array - store now the mesh offset in it
+            offset[n] = cnt;
+            cnt = (unsigned int)(pip - dest->mMeshes);
+        }
+    }
+
+    std::vector<NodeAttachmentInfo> nodes;
+    nodes.reserve(srcList.size());
+
+    // ----------------------------------------------------------------------------
+    // Now generate the output node graph. We need to make those
+    // names in the graph that are referenced by anims or lights
+    // or cameras unique. So we add a prefix to them ... $<rand>_
+    // We could also use a counter, but using a random value allows us to
+    // use just one prefix if we are joining multiple scene hierarchies recursively.
+    // Chances are quite good we don't collide, so we try that ...
+    // ----------------------------------------------------------------------------
+
+    // Allocate space for light sources, cameras and animations
+    aiLight **ppLights = dest->mLights = (dest->mNumLights ? new aiLight *[dest->mNumLights] : nullptr);
+
+    aiCamera **ppCameras = dest->mCameras = (dest->mNumCameras ? new aiCamera *[dest->mNumCameras] : nullptr);
+
+    aiAnimation **ppAnims = dest->mAnimations = (dest->mNumAnimations ? new aiAnimation *[dest->mNumAnimations] : nullptr);
+
+    for (int n = static_cast<int>(src.size() - 1); n >= 0; --n) /* !!! important !!! */
+    {
+        SceneHelper *cur = &src[n];
+        aiNode *node;
+
+        // To offset or not to offset, this is the question
+        if (n != (int)duplicates[n]) {
+            // Get full scene-graph copy
+            Copy(&node, (*cur)->mRootNode);
+            OffsetNodeMeshIndices(node, offset[duplicates[n]]);
+
+            if (flags & AI_INT_MERGE_SCENE_DUPLICATES_DEEP_CPY) {
+                // (note:) they are already 'offseted' by offset[duplicates[n]]
+                OffsetNodeMeshIndices(node, offset[n] - offset[duplicates[n]]);
+            }
+        } else // if (n == duplicates[n])
+        {
+            node = (*cur)->mRootNode;
+            OffsetNodeMeshIndices(node, offset[n]);
+        }
+        if (n) // src[0] is the master node
+            nodes.push_back(NodeAttachmentInfo(node, srcList[n - 1].attachToNode, n));
+
+        // add name prefixes?
+        if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
+
+            // or the whole scenegraph
+            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+                AddNodePrefixesChecked(node, (*cur).id, (*cur).idlen, src, n);
+            } else
+                AddNodePrefixes(node, (*cur).id, (*cur).idlen);
+
+            // meshes
+            for (unsigned int i = 0; i < (*cur)->mNumMeshes; ++i) {
+                aiMesh *mesh = (*cur)->mMeshes[i];
+
+                // rename all bones
+                for (unsigned int a = 0; a < mesh->mNumBones; ++a) {
+                    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+                        if (!FindNameMatch(mesh->mBones[a]->mName, src, n))
+                            continue;
+                    }
+                    PrefixString(mesh->mBones[a]->mName, (*cur).id, (*cur).idlen);
+                }
+            }
+        }
+
+        // --------------------------------------------------------------------
+        // Copy light sources
+        for (unsigned int i = 0; i < (*cur)->mNumLights; ++i, ++ppLights) {
+            if (n != (int)duplicates[n]) // duplicate scene?
+            {
+                Copy(ppLights, (*cur)->mLights[i]);
+            } else
+                *ppLights = (*cur)->mLights[i];
+
+            // Add name prefixes?
+            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
+                if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+                    if (!FindNameMatch((*ppLights)->mName, src, n))
+                        continue;
+                }
+
+                PrefixString((*ppLights)->mName, (*cur).id, (*cur).idlen);
+            }
+        }
+
+        // --------------------------------------------------------------------
+        // Copy cameras
+        for (unsigned int i = 0; i < (*cur)->mNumCameras; ++i, ++ppCameras) {
+            if (n != (int)duplicates[n]) // duplicate scene?
+            {
+                Copy(ppCameras, (*cur)->mCameras[i]);
+            } else
+                *ppCameras = (*cur)->mCameras[i];
+
+            // Add name prefixes?
+            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
+                if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+                    if (!FindNameMatch((*ppCameras)->mName, src, n))
+                        continue;
+                }
+
+                PrefixString((*ppCameras)->mName, (*cur).id, (*cur).idlen);
+            }
+        }
+
+        // --------------------------------------------------------------------
+        // Copy animations
+        for (unsigned int i = 0; i < (*cur)->mNumAnimations; ++i, ++ppAnims) {
+            if (n != (int)duplicates[n]) // duplicate scene?
+            {
+                Copy(ppAnims, (*cur)->mAnimations[i]);
+            } else
+                *ppAnims = (*cur)->mAnimations[i];
+
+            // Add name prefixes?
+            if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES) {
+                if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+                    if (!FindNameMatch((*ppAnims)->mName, src, n))
+                        continue;
+                }
+
+                PrefixString((*ppAnims)->mName, (*cur).id, (*cur).idlen);
+
+                // don't forget to update all node animation channels
+                for (unsigned int a = 0; a < (*ppAnims)->mNumChannels; ++a) {
+                    if (flags & AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY) {
+                        if (!FindNameMatch((*ppAnims)->mChannels[a]->mNodeName, src, n))
+                            continue;
+                    }
+
+                    PrefixString((*ppAnims)->mChannels[a]->mNodeName, (*cur).id, (*cur).idlen);
+                }
+            }
+        }
+    }
+
+    // Now build the output graph
+    AttachToGraph(master, nodes);
+    dest->mRootNode = master->mRootNode;
+
+    // Check whether we succeeded at building the output graph
+    for (std::vector<NodeAttachmentInfo>::iterator it = nodes.begin();
+            it != nodes.end(); ++it) {
+        if (!(*it).resolved) {
+            if (flags & AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS) {
+                // search for this attachment point in all other imported scenes, too.
+                for (unsigned int n = 0; n < src.size(); ++n) {
+                    if (n != (*it).src_idx) {
+                        AttachToGraph(src[n].scene, nodes);
+                        if ((*it).resolved)
+                            break;
+                    }
+                }
+            }
+            if (!(*it).resolved) {
+                ASSIMP_LOG_ERROR("SceneCombiner: Failed to resolve attachment ", (*it).node->mName.data,
+                        " ", (*it).attachToNode->mName.data);
+            }
+        }
+    }
+
+    // now delete all input scenes. Make sure duplicate scenes aren't
+    // deleted more than one time
+    for (unsigned int n = 0; n < src.size(); ++n) {
+        if (n != duplicates[n]) // duplicate scene?
+            continue;
+
+        aiScene *deleteMe = src[n].scene;
+
+        // We need to delete the arrays before the destructor is called -
+        // we are reusing the array members
+        delete[] deleteMe->mMeshes;
+        deleteMe->mMeshes = nullptr;
+        delete[] deleteMe->mCameras;
+        deleteMe->mCameras = nullptr;
+        delete[] deleteMe->mLights;
+        deleteMe->mLights = nullptr;
+        delete[] deleteMe->mMaterials;
+        deleteMe->mMaterials = nullptr;
+        delete[] deleteMe->mAnimations;
+        deleteMe->mAnimations = nullptr;
+        delete[] deleteMe->mTextures;
+        deleteMe->mTextures = nullptr;
+
+        deleteMe->mRootNode = nullptr;
+
+        // Now we can safely delete the scene
+        delete deleteMe;
+    }
+
+    // Check flags
+    if (!dest->mNumMeshes || !dest->mNumMaterials) {
+        dest->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+    }
+
+    // We're finished
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build a list of unique bones
+void SceneCombiner::BuildUniqueBoneList(std::list<BoneWithHash> &asBones,
+        std::vector<aiMesh *>::const_iterator it,
+        std::vector<aiMesh *>::const_iterator end) {
+    unsigned int iOffset = 0;
+    for (; it != end; ++it) {
+        for (unsigned int l = 0; l < (*it)->mNumBones; ++l) {
+            aiBone *p = (*it)->mBones[l];
+            uint32_t itml = SuperFastHash(p->mName.data, (unsigned int)p->mName.length);
+
+            std::list<BoneWithHash>::iterator it2 = asBones.begin();
+            std::list<BoneWithHash>::iterator end2 = asBones.end();
+
+            for (; it2 != end2; ++it2) {
+                if ((*it2).first == itml) {
+                    (*it2).pSrcBones.push_back(BoneSrcIndex(p, iOffset));
+                    break;
+                }
+            }
+            if (end2 == it2) {
+                // need to begin a new bone entry
+                asBones.push_back(BoneWithHash());
+                BoneWithHash &btz = asBones.back();
+
+                // setup members
+                btz.first = itml;
+                btz.second = &p->mName;
+                btz.pSrcBones.push_back(BoneSrcIndex(p, iOffset));
+            }
+        }
+        iOffset += (*it)->mNumVertices;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Merge a list of bones
+void SceneCombiner::MergeBones(aiMesh *out, std::vector<aiMesh *>::const_iterator it,
+        std::vector<aiMesh *>::const_iterator end) {
+    if (nullptr == out || out->mNumBones == 0) {
+        return;
+    }
+
+    // find we need to build an unique list of all bones.
+    // we work with hashes to make the comparisons MUCH faster,
+    // at least if we have many bones.
+    std::list<BoneWithHash> asBones;
+    BuildUniqueBoneList(asBones, it, end);
+
+    // now create the output bones
+    out->mNumBones = 0;
+    out->mBones = new aiBone *[asBones.size()];
+
+    for (std::list<BoneWithHash>::const_iterator boneIt = asBones.begin(), boneEnd = asBones.end(); boneIt != boneEnd; ++boneIt) {
+        // Allocate a bone and setup it's name
+        aiBone *pc = out->mBones[out->mNumBones++] = new aiBone();
+        pc->mName = aiString(*(boneIt->second));
+
+        std::vector<BoneSrcIndex>::const_iterator wend = boneIt->pSrcBones.end();
+
+        // Loop through all bones to be joined for this bone
+        for (std::vector<BoneSrcIndex>::const_iterator wmit = boneIt->pSrcBones.begin(); wmit != wend; ++wmit) {
+            pc->mNumWeights += (*wmit).first->mNumWeights;
+
+            // NOTE: different offset matrices for bones with equal names
+            // are - at the moment - not handled correctly.
+            if (wmit != boneIt->pSrcBones.begin() && pc->mOffsetMatrix != wmit->first->mOffsetMatrix) {
+                ASSIMP_LOG_WARN("Bones with equal names but different offset matrices can't be joined at the moment");
+                continue;
+            }
+            pc->mOffsetMatrix = wmit->first->mOffsetMatrix;
+        }
+
+        // Allocate the vertex weight array
+        aiVertexWeight *avw = pc->mWeights = new aiVertexWeight[pc->mNumWeights];
+
+        // And copy the final weights - adjust the vertex IDs by the
+        // face index offset of the corresponding mesh.
+        for (std::vector<BoneSrcIndex>::const_iterator wmit = (*boneIt).pSrcBones.begin(); wmit != (*boneIt).pSrcBones.end(); ++wmit) {
+            if (wmit == wend) {
+                break;
+            }
+
+            aiBone *pip = (*wmit).first;
+            for (unsigned int mp = 0; mp < pip->mNumWeights; ++mp, ++avw) {
+                const aiVertexWeight &vfi = pip->mWeights[mp];
+                avw->mWeight = vfi.mWeight;
+                avw->mVertexId = vfi.mVertexId + (*wmit).second;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Merge a list of meshes
+void SceneCombiner::MergeMeshes(aiMesh **_out, unsigned int /*flags*/,
+        std::vector<aiMesh *>::const_iterator begin,
+        std::vector<aiMesh *>::const_iterator end) {
+    if (nullptr == _out) {
+        return;
+    }
+
+    if (begin == end) {
+        *_out = nullptr; // no meshes ...
+        return;
+    }
+
+    // Allocate the output mesh
+    aiMesh *out = *_out = new aiMesh();
+    out->mMaterialIndex = (*begin)->mMaterialIndex;
+
+    std::string name;
+    // Find out how much output storage we'll need
+    for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+        const char *meshName((*it)->mName.C_Str());
+        name += std::string(meshName);
+        if (it != end - 1) {
+            name += ".";
+        }
+        out->mNumVertices += (*it)->mNumVertices;
+        out->mNumFaces += (*it)->mNumFaces;
+        out->mNumBones += (*it)->mNumBones;
+
+        // combine primitive type flags
+        out->mPrimitiveTypes |= (*it)->mPrimitiveTypes;
+    }
+    out->mName.Set(name.c_str());
+
+    if (out->mNumVertices) {
+        aiVector3D *pv2;
+
+        // copy vertex positions
+        if ((**begin).HasPositions()) {
+
+            pv2 = out->mVertices = new aiVector3D[out->mNumVertices];
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mVertices) {
+                    ::memcpy(pv2, (*it)->mVertices, (*it)->mNumVertices * sizeof(aiVector3D));
+                } else
+                    ASSIMP_LOG_WARN("JoinMeshes: Positions expected but input mesh contains no positions");
+                pv2 += (*it)->mNumVertices;
+            }
+        }
+        // copy normals
+        if ((**begin).HasNormals()) {
+
+            pv2 = out->mNormals = new aiVector3D[out->mNumVertices];
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mNormals) {
+                    ::memcpy(pv2, (*it)->mNormals, (*it)->mNumVertices * sizeof(aiVector3D));
+                } else {
+                    ASSIMP_LOG_WARN("JoinMeshes: Normals expected but input mesh contains no normals");
+                }
+                pv2 += (*it)->mNumVertices;
+            }
+        }
+        // copy tangents and bi-tangents
+        if ((**begin).HasTangentsAndBitangents()) {
+
+            pv2 = out->mTangents = new aiVector3D[out->mNumVertices];
+            aiVector3D *pv2b = out->mBitangents = new aiVector3D[out->mNumVertices];
+
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mTangents) {
+                    ::memcpy(pv2, (*it)->mTangents, (*it)->mNumVertices * sizeof(aiVector3D));
+                    ::memcpy(pv2b, (*it)->mBitangents, (*it)->mNumVertices * sizeof(aiVector3D));
+                } else {
+                    ASSIMP_LOG_WARN("JoinMeshes: Tangents expected but input mesh contains no tangents");
+                }
+                pv2 += (*it)->mNumVertices;
+                pv2b += (*it)->mNumVertices;
+            }
+        }
+        // copy texture coordinates
+        unsigned int n = 0;
+        while ((**begin).HasTextureCoords(n)) {
+            out->mNumUVComponents[n] = (*begin)->mNumUVComponents[n];
+
+            pv2 = out->mTextureCoords[n] = new aiVector3D[out->mNumVertices];
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mTextureCoords[n]) {
+                    ::memcpy(pv2, (*it)->mTextureCoords[n], (*it)->mNumVertices * sizeof(aiVector3D));
+                } else {
+                    ASSIMP_LOG_WARN("JoinMeshes: UVs expected but input mesh contains no UVs");
+                }
+                pv2 += (*it)->mNumVertices;
+            }
+            ++n;
+        }
+        // copy vertex colors
+        n = 0;
+        while ((**begin).HasVertexColors(n)) {
+            aiColor4D *pVec2 = out->mColors[n] = new aiColor4D[out->mNumVertices];
+            for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+                if ((*it)->mColors[n]) {
+                    ::memcpy(pVec2, (*it)->mColors[n], (*it)->mNumVertices * sizeof(aiColor4D));
+                } else {
+                    ASSIMP_LOG_WARN("JoinMeshes: VCs expected but input mesh contains no VCs");
+                }
+                pVec2 += (*it)->mNumVertices;
+            }
+            ++n;
+        }
+    }
+
+    if (out->mNumFaces) // just for safety
+    {
+        // copy faces
+        out->mFaces = new aiFace[out->mNumFaces];
+        aiFace *pf2 = out->mFaces;
+
+        unsigned int ofs = 0;
+        for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it) {
+            for (unsigned int m = 0; m < (*it)->mNumFaces; ++m, ++pf2) {
+                aiFace &face = (*it)->mFaces[m];
+                pf2->mNumIndices = face.mNumIndices;
+                pf2->mIndices = face.mIndices;
+
+                if (ofs) {
+                    // add the offset to the vertex
+                    for (unsigned int q = 0; q < face.mNumIndices; ++q) {
+                        face.mIndices[q] += ofs;
+                    }
+                }
+                face.mIndices = nullptr;
+            }
+            ofs += (*it)->mNumVertices;
+        }
+    }
+
+    // bones - as this is quite lengthy, I moved the code to a separate function
+    if (out->mNumBones)
+        MergeBones(out, begin, end);
+
+    // delete all source meshes
+    for (std::vector<aiMesh *>::const_iterator it = begin; it != end; ++it)
+        delete *it;
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::MergeMaterials(aiMaterial **dest,
+        std::vector<aiMaterial *>::const_iterator begin,
+        std::vector<aiMaterial *>::const_iterator end) {
+    if (nullptr == dest) {
+        return;
+    }
+
+    if (begin == end) {
+        *dest = nullptr; // no materials ...
+        return;
+    }
+
+    // Allocate the output material
+    aiMaterial *out = *dest = new aiMaterial();
+
+    // Get the maximal number of properties
+    unsigned int size = 0;
+    for (std::vector<aiMaterial *>::const_iterator it = begin; it != end; ++it) {
+        size += (*it)->mNumProperties;
+    }
+
+    out->Clear();
+    delete[] out->mProperties;
+
+    out->mNumAllocated = size;
+    out->mNumProperties = 0;
+    out->mProperties = new aiMaterialProperty *[out->mNumAllocated];
+
+    for (std::vector<aiMaterial *>::const_iterator it = begin; it != end; ++it) {
+        for (unsigned int i = 0; i < (*it)->mNumProperties; ++i) {
+            aiMaterialProperty *sprop = (*it)->mProperties[i];
+
+            // Test if we already have a matching property
+            const aiMaterialProperty *prop_exist;
+            if (aiGetMaterialProperty(out, sprop->mKey.C_Str(), sprop->mSemantic, sprop->mIndex, &prop_exist) != AI_SUCCESS) {
+                // If not, we add it to the new material
+                aiMaterialProperty *prop = out->mProperties[out->mNumProperties] = new aiMaterialProperty();
+
+                prop->mDataLength = sprop->mDataLength;
+                prop->mData = new char[prop->mDataLength];
+                ::memcpy(prop->mData, sprop->mData, prop->mDataLength);
+
+                prop->mIndex = sprop->mIndex;
+                prop->mSemantic = sprop->mSemantic;
+                prop->mKey = sprop->mKey;
+                prop->mType = sprop->mType;
+
+                out->mNumProperties++;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename Type>
+inline void CopyPtrArray(Type **&dest, const Type *const *src, ai_uint num) {
+    if (!num) {
+        dest = nullptr;
+        return;
+    }
+    dest = new Type *[num];
+    for (ai_uint i = 0; i < num; ++i) {
+        SceneCombiner::Copy(&dest[i], src[i]);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+template <typename Type>
+inline void GetArrayCopy(Type *&dest, ai_uint num) {
+    if (!dest) {
+        return;
+    }
+    Type *old = dest;
+
+    dest = new Type[num];
+    ::memcpy(dest, old, sizeof(Type) * num);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::CopySceneFlat(aiScene **_dest, const aiScene *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    // reuse the old scene or allocate a new?
+    if (*_dest) {
+        (*_dest)->~aiScene();
+        new (*_dest) aiScene();
+    } else {
+        *_dest = new aiScene();
+    }
+    CopyScene(_dest, src, false);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::CopyScene(aiScene **_dest, const aiScene *src, bool allocate) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    if (allocate) {
+        *_dest = new aiScene();
+    }
+    aiScene *dest = *_dest;
+    ai_assert(nullptr != dest);
+
+    // copy metadata
+    if (nullptr != src->mMetaData) {
+        dest->mMetaData = new aiMetadata(*src->mMetaData);
+    }
+
+    // copy animations
+    dest->mNumAnimations = src->mNumAnimations;
+    CopyPtrArray(dest->mAnimations, src->mAnimations,
+            dest->mNumAnimations);
+
+    // copy textures
+    dest->mNumTextures = src->mNumTextures;
+    CopyPtrArray(dest->mTextures, src->mTextures,
+            dest->mNumTextures);
+
+    // copy materials
+    dest->mNumMaterials = src->mNumMaterials;
+    CopyPtrArray(dest->mMaterials, src->mMaterials,
+            dest->mNumMaterials);
+
+    // copy lights
+    dest->mNumLights = src->mNumLights;
+    CopyPtrArray(dest->mLights, src->mLights,
+            dest->mNumLights);
+
+    // copy cameras
+    dest->mNumCameras = src->mNumCameras;
+    CopyPtrArray(dest->mCameras, src->mCameras,
+            dest->mNumCameras);
+
+    // copy meshes
+    dest->mNumMeshes = src->mNumMeshes;
+    CopyPtrArray(dest->mMeshes, src->mMeshes,
+            dest->mNumMeshes);
+
+    // now - copy the root node of the scene (deep copy, too)
+    Copy(&dest->mRootNode, src->mRootNode);
+
+    // and keep the flags ...
+    dest->mFlags = src->mFlags;
+
+    // source private data might be nullptr if the scene is user-allocated (i.e. for use with the export API)
+    if (dest->mPrivate != nullptr) {
+        ScenePriv(dest)->mPPStepsApplied = ScenePriv(src) ? ScenePriv(src)->mPPStepsApplied : 0;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiMesh **_dest, const aiMesh *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiMesh *dest = *_dest = new aiMesh();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mVertices, dest->mNumVertices);
+    GetArrayCopy(dest->mNormals, dest->mNumVertices);
+    GetArrayCopy(dest->mTangents, dest->mNumVertices);
+    GetArrayCopy(dest->mBitangents, dest->mNumVertices);
+
+    unsigned int n = 0;
+    while (dest->HasTextureCoords(n)) {
+        GetArrayCopy(dest->mTextureCoords[n++], dest->mNumVertices);
+    }
+
+    n = 0;
+    while (dest->HasVertexColors(n)) {
+        GetArrayCopy(dest->mColors[n++], dest->mNumVertices);
+    }
+
+    // make a deep copy of all bones
+    CopyPtrArray(dest->mBones, dest->mBones, dest->mNumBones);
+
+    // make a deep copy of all faces
+    GetArrayCopy(dest->mFaces, dest->mNumFaces);
+    for (unsigned int i = 0; i < dest->mNumFaces; ++i) {
+        aiFace &f = dest->mFaces[i];
+        GetArrayCopy(f.mIndices, f.mNumIndices);
+    }
+
+    // make a deep copy of all blend shapes
+    CopyPtrArray(dest->mAnimMeshes, dest->mAnimMeshes, dest->mNumAnimMeshes);
+
+    // make a deep copy of all texture coordinate names
+    if (src->mTextureCoordsNames != nullptr) {
+        dest->mTextureCoordsNames = new aiString *[AI_MAX_NUMBER_OF_TEXTURECOORDS] {};
+        for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+            Copy(&dest->mTextureCoordsNames[i], src->mTextureCoordsNames[i]);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiAnimMesh **_dest, const aiAnimMesh *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiAnimMesh *dest = *_dest = new aiAnimMesh();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mVertices, dest->mNumVertices);
+    GetArrayCopy(dest->mNormals, dest->mNumVertices);
+    GetArrayCopy(dest->mTangents, dest->mNumVertices);
+    GetArrayCopy(dest->mBitangents, dest->mNumVertices);
+
+    unsigned int n = 0;
+    while (dest->HasTextureCoords(n))
+        GetArrayCopy(dest->mTextureCoords[n++], dest->mNumVertices);
+
+    n = 0;
+    while (dest->HasVertexColors(n))
+        GetArrayCopy(dest->mColors[n++], dest->mNumVertices);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiMaterial **_dest, const aiMaterial *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiMaterial *dest = (aiMaterial *)(*_dest = new aiMaterial());
+
+    dest->Clear();
+    delete[] dest->mProperties;
+
+    dest->mNumAllocated = src->mNumAllocated;
+    dest->mNumProperties = src->mNumProperties;
+    dest->mProperties = new aiMaterialProperty *[dest->mNumAllocated];
+
+    for (unsigned int i = 0; i < dest->mNumProperties; ++i) {
+        aiMaterialProperty *prop = dest->mProperties[i] = new aiMaterialProperty();
+        aiMaterialProperty *sprop = src->mProperties[i];
+
+        prop->mDataLength = sprop->mDataLength;
+        prop->mData = new char[prop->mDataLength];
+        ::memcpy(prop->mData, sprop->mData, prop->mDataLength);
+
+        prop->mIndex = sprop->mIndex;
+        prop->mSemantic = sprop->mSemantic;
+        prop->mKey = sprop->mKey;
+        prop->mType = sprop->mType;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiTexture **_dest, const aiTexture *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiTexture *dest = *_dest = new aiTexture();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays. We must do it manually here
+    const char *old = (const char *)dest->pcData;
+    if (old) {
+        unsigned int cpy;
+        if (!dest->mHeight)
+            cpy = dest->mWidth;
+        else
+            cpy = dest->mHeight * dest->mWidth * sizeof(aiTexel);
+
+        if (!cpy) {
+            dest->pcData = nullptr;
+            return;
+        }
+        // the cast is legal, the aiTexel c'tor does nothing important
+        dest->pcData = (aiTexel *)new char[cpy];
+        ::memcpy(dest->pcData, old, cpy);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiAnimation **_dest, const aiAnimation *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiAnimation *dest = *_dest = new aiAnimation();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays
+    CopyPtrArray(dest->mChannels, src->mChannels, dest->mNumChannels);
+    CopyPtrArray(dest->mMorphMeshChannels, src->mMorphMeshChannels, dest->mNumMorphMeshChannels);
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiNodeAnim **_dest, const aiNodeAnim *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiNodeAnim *dest = *_dest = new aiNodeAnim();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mPositionKeys, dest->mNumPositionKeys);
+    GetArrayCopy(dest->mScalingKeys, dest->mNumScalingKeys);
+    GetArrayCopy(dest->mRotationKeys, dest->mNumRotationKeys);
+}
+
+void SceneCombiner::Copy(aiMeshMorphAnim **_dest, const aiMeshMorphAnim *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiMeshMorphAnim *dest = *_dest = new aiMeshMorphAnim();
+
+    // get a flat copy
+    *dest = *src;
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mKeys, dest->mNumKeys);
+    for (ai_uint i = 0; i < dest->mNumKeys; ++i) {
+        dest->mKeys[i].mValues = new unsigned int[dest->mKeys[i].mNumValuesAndWeights];
+        dest->mKeys[i].mWeights = new double[dest->mKeys[i].mNumValuesAndWeights];
+        ::memcpy(dest->mKeys[i].mValues, src->mKeys[i].mValues, dest->mKeys[i].mNumValuesAndWeights * sizeof(unsigned int));
+        ::memcpy(dest->mKeys[i].mWeights, src->mKeys[i].mWeights, dest->mKeys[i].mNumValuesAndWeights * sizeof(double));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiCamera **_dest, const aiCamera *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiCamera *dest = *_dest = new aiCamera();
+
+    // get a flat copy, that's already OK
+    *dest = *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiLight **_dest, const aiLight *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiLight *dest = *_dest = new aiLight();
+
+    // get a flat copy, that's already OK
+    *dest = *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiBone **_dest, const aiBone *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiBone *dest = *_dest = new aiBone();
+
+    // get a flat copy
+    *dest = *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiNode **_dest, const aiNode *src) {
+    ai_assert(nullptr != _dest);
+    ai_assert(nullptr != src);
+
+    aiNode *dest = *_dest = new aiNode();
+
+    // get a flat copy
+    *dest = *src;
+
+    if (src->mMetaData) {
+        Copy(&dest->mMetaData, src->mMetaData);
+    }
+
+    // and reallocate all arrays
+    GetArrayCopy(dest->mMeshes, dest->mNumMeshes);
+    CopyPtrArray(dest->mChildren, src->mChildren, dest->mNumChildren);
+
+    // need to set the mParent fields to the created aiNode.
+    for (unsigned int i = 0; i < dest->mNumChildren; i++) {
+        dest->mChildren[i]->mParent = dest;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiMetadata **_dest, const aiMetadata *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    if (0 == src->mNumProperties) {
+        return;
+    }
+
+    aiMetadata *dest = *_dest = aiMetadata::Alloc(src->mNumProperties);
+    std::copy(src->mKeys, src->mKeys + src->mNumProperties, dest->mKeys);
+
+    for (unsigned int i = 0; i < src->mNumProperties; ++i) {
+        aiMetadataEntry &in = src->mValues[i];
+        aiMetadataEntry &out = dest->mValues[i];
+        out.mType = in.mType;
+        switch (dest->mValues[i].mType) {
+        case AI_BOOL:
+            out.mData = new bool(*static_cast<bool *>(in.mData));
+            break;
+        case AI_INT32:
+            out.mData = new int32_t(*static_cast<int32_t *>(in.mData));
+            break;
+        case AI_UINT64:
+            out.mData = new uint64_t(*static_cast<uint64_t *>(in.mData));
+            break;
+        case AI_FLOAT:
+            out.mData = new float(*static_cast<float *>(in.mData));
+            break;
+        case AI_DOUBLE:
+            out.mData = new double(*static_cast<double *>(in.mData));
+            break;
+        case AI_AISTRING:
+            out.mData = new aiString(*static_cast<aiString *>(in.mData));
+            break;
+        case AI_AIVECTOR3D:
+            out.mData = new aiVector3D(*static_cast<aiVector3D *>(in.mData));
+            break;
+        default:
+            ai_assert(false);
+            break;
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void SceneCombiner::Copy(aiString **_dest, const aiString *src) {
+    if (nullptr == _dest || nullptr == src) {
+        return;
+    }
+
+    aiString *dest = *_dest = new aiString();
+
+    // get a flat copy
+    *dest = *src;
+}
+
+#if (__GNUC__ >= 8 && __GNUC_MINOR__ >= 0)
+#pragma GCC diagnostic pop
+#endif
+
+} // Namespace Assimp