switch to tinyobj and nanovg from assimp and cairo

1 files changed, 0 insertions, 1060 deletions

diff --git a/libs/assimp/code/AssetLib/MD3/MD3Loader.cpp b/libs/assimp/code/AssetLib/MD3/MD3Loader.cpp
deleted file mode 100644
index 6120bd8..0000000
--- a/libs/assimp/code/AssetLib/MD3/MD3Loader.cpp
+++ /dev/null
@@ -1,1060 +0,0 @@
-/*
----------------------------------------------------------------------------
-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 MD3Loader.cpp
- *  @brief Implementation of the MD3 importer class
- *
- *  Sources:
- *     http://www.gamers.org/dEngine/quake3/UQ3S
- *     http://linux.ucla.edu/~phaethon/q3/formats/md3format.html
- *     http://www.heppler.com/shader/shader/
- */
-
-#ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
-
-#include "AssetLib/MD3/MD3Loader.h"
-#include "Common/Importer.h"
-
-#include <assimp/GenericProperty.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/RemoveComments.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/importerdesc.h>
-#include <assimp/material.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/IOSystem.hpp>
-
-#include <cctype>
-#include <memory>
-
-using namespace Assimp;
-
-static const aiImporterDesc desc = {
-    "Quake III Mesh Importer",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "md3"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Convert a Q3 shader blend function to the appropriate enum value
-Q3Shader::BlendFunc StringToBlendFunc(const std::string &m) {
-    if (m == "GL_ONE") {
-        return Q3Shader::BLEND_GL_ONE;
-    }
-    if (m == "GL_ZERO") {
-        return Q3Shader::BLEND_GL_ZERO;
-    }
-    if (m == "GL_SRC_ALPHA") {
-        return Q3Shader::BLEND_GL_SRC_ALPHA;
-    }
-    if (m == "GL_ONE_MINUS_SRC_ALPHA") {
-        return Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA;
-    }
-    if (m == "GL_ONE_MINUS_DST_COLOR") {
-        return Q3Shader::BLEND_GL_ONE_MINUS_DST_COLOR;
-    }
-    ASSIMP_LOG_ERROR("Q3Shader: Unknown blend function: ", m);
-    return Q3Shader::BLEND_NONE;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load a Quake 3 shader
-bool Q3Shader::LoadShader(ShaderData &fill, const std::string &pFile, IOSystem *io) {
-    std::unique_ptr<IOStream> file(io->Open(pFile, "rt"));
-    if (!file.get())
-        return false; // if we can't access the file, don't worry and return
-
-    ASSIMP_LOG_INFO("Loading Quake3 shader file ", pFile);
-
-    // read file in memory
-    const size_t s = file->FileSize();
-    std::vector<char> _buff(s + 1);
-    file->Read(&_buff[0], s, 1);
-    _buff[s] = 0;
-
-    // remove comments from it (C++ style)
-    CommentRemover::RemoveLineComments("//", &_buff[0]);
-    const char *buff = &_buff[0];
-
-    Q3Shader::ShaderDataBlock *curData = nullptr;
-    Q3Shader::ShaderMapBlock *curMap = nullptr;
-
-    // read line per line
-    for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
-
-        if (*buff == '{') {
-            ++buff;
-
-            // append to last section, if any
-            if (!curData) {
-                ASSIMP_LOG_ERROR("Q3Shader: Unexpected shader section token \'{\'");
-                return true; // still no failure, the file is there
-            }
-
-            // read this data section
-            for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
-                if (*buff == '{') {
-                    ++buff;
-                    // add new map section
-                    curData->maps.push_back(Q3Shader::ShaderMapBlock());
-                    curMap = &curData->maps.back();
-
-                    for (; SkipSpacesAndLineEnd(&buff); SkipLine(&buff)) {
-                        // 'map' - Specifies texture file name
-                        if (TokenMatchI(buff, "map", 3) || TokenMatchI(buff, "clampmap", 8)) {
-                            curMap->name = GetNextToken(buff);
-                        }
-                        // 'blendfunc' - Alpha blending mode
-                        else if (TokenMatchI(buff, "blendfunc", 9)) {
-                            const std::string blend_src = GetNextToken(buff);
-                            if (blend_src == "add") {
-                                curMap->blend_src = Q3Shader::BLEND_GL_ONE;
-                                curMap->blend_dest = Q3Shader::BLEND_GL_ONE;
-                            } else if (blend_src == "filter") {
-                                curMap->blend_src = Q3Shader::BLEND_GL_DST_COLOR;
-                                curMap->blend_dest = Q3Shader::BLEND_GL_ZERO;
-                            } else if (blend_src == "blend") {
-                                curMap->blend_src = Q3Shader::BLEND_GL_SRC_ALPHA;
-                                curMap->blend_dest = Q3Shader::BLEND_GL_ONE_MINUS_SRC_ALPHA;
-                            } else {
-                                curMap->blend_src = StringToBlendFunc(blend_src);
-                                curMap->blend_dest = StringToBlendFunc(GetNextToken(buff));
-                            }
-                        }
-                        // 'alphafunc' - Alpha testing mode
-                        else if (TokenMatchI(buff, "alphafunc", 9)) {
-                            const std::string at = GetNextToken(buff);
-                            if (at == "GT0") {
-                                curMap->alpha_test = Q3Shader::AT_GT0;
-                            } else if (at == "LT128") {
-                                curMap->alpha_test = Q3Shader::AT_LT128;
-                            } else if (at == "GE128") {
-                                curMap->alpha_test = Q3Shader::AT_GE128;
-                            }
-                        } else if (*buff == '}') {
-                            ++buff;
-                            // close this map section
-                            curMap = nullptr;
-                            break;
-                        }
-                    }
-
-                } else if (*buff == '}') {
-                    ++buff;
-                    curData = nullptr;
-                    break;
-                }
-
-                // 'cull' specifies culling behaviour for the model
-                else if (TokenMatchI(buff, "cull", 4)) {
-                    SkipSpaces(&buff);
-                    if (!ASSIMP_strincmp(buff, "back", 4)) { // render face's backside, does not function in Q3 engine (bug)
-                        curData->cull = Q3Shader::CULL_CCW;
-                    } else if (!ASSIMP_strincmp(buff, "front", 5)) { // is not valid keyword in Q3, but occurs in shaders
-                        curData->cull = Q3Shader::CULL_CW;
-                    } else if (!ASSIMP_strincmp(buff, "none", 4) || !ASSIMP_strincmp(buff, "twosided", 8) || !ASSIMP_strincmp(buff, "disable", 7)) {
-                        curData->cull = Q3Shader::CULL_NONE;
-                    } else {
-                        ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode");
-                    }
-                }
-            }
-        } else {
-            // add new section
-            fill.blocks.push_back(Q3Shader::ShaderDataBlock());
-            curData = &fill.blocks.back();
-
-            // get the name of this section
-            curData->name = GetNextToken(buff);
-        }
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Load a Quake 3 skin
-bool Q3Shader::LoadSkin(SkinData &fill, const std::string &pFile, IOSystem *io) {
-    std::unique_ptr<IOStream> file(io->Open(pFile, "rt"));
-    if (!file.get())
-        return false; // if we can't access the file, don't worry and return
-
-    ASSIMP_LOG_INFO("Loading Quake3 skin file ", pFile);
-
-    // read file in memory
-    const size_t s = file->FileSize();
-    std::vector<char> _buff(s + 1);
-    const char *buff = &_buff[0];
-    file->Read(&_buff[0], s, 1);
-    _buff[s] = 0;
-
-    // remove commas
-    std::replace(_buff.begin(), _buff.end(), ',', ' ');
-
-    // read token by token and fill output table
-    for (; *buff;) {
-        SkipSpacesAndLineEnd(&buff);
-
-        // get first identifier
-        std::string ss = GetNextToken(buff);
-
-        // ignore tokens starting with tag_
-        if (!::strncmp(&ss[0], "tag_", std::min((size_t)4, ss.length())))
-            continue;
-
-        fill.textures.push_back(SkinData::TextureEntry());
-        SkinData::TextureEntry &entry = fill.textures.back();
-
-        entry.first = ss;
-        entry.second = GetNextToken(buff);
-    }
-    return true;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert Q3Shader to material
-void Q3Shader::ConvertShaderToMaterial(aiMaterial *out, const ShaderDataBlock &shader) {
-    ai_assert(nullptr != out);
-
-    /*  IMPORTANT: This is not a real conversion. Actually we're just guessing and
-     *  hacking around to build an aiMaterial that looks nearly equal to the
-     *  original Quake 3 shader. We're missing some important features like
-     *  animatable material properties in our material system, but at least
-     *  multiple textures should be handled correctly.
-     */
-
-    // Two-sided material?
-    if (shader.cull == Q3Shader::CULL_NONE) {
-        const int twosided = 1;
-        out->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
-    }
-
-    unsigned int cur_emissive = 0, cur_diffuse = 0, cur_lm = 0;
-
-    // Iterate through all textures
-    for (std::list<Q3Shader::ShaderMapBlock>::const_iterator it = shader.maps.begin(); it != shader.maps.end(); ++it) {
-
-        // CONVERSION BEHAVIOUR:
-        //
-        //
-        // If the texture is additive
-        //  - if it is the first texture, assume additive blending for the whole material
-        //  - otherwise register it as emissive texture.
-        //
-        // If the texture is using standard blend (or if the blend mode is unknown)
-        //  - if first texture: assume default blending for material
-        //  - in any case: set it as diffuse texture
-        //
-        // If the texture is using 'filter' blending
-        //  - take as lightmap
-        //
-        // Textures with alpha funcs
-        //  - aiTextureFlags_UseAlpha is set (otherwise aiTextureFlags_NoAlpha is explicitly set)
-        aiString s((*it).name);
-        aiTextureType type;
-        unsigned int index;
-
-        if ((*it).blend_src == Q3Shader::BLEND_GL_ONE && (*it).blend_dest == Q3Shader::BLEND_GL_ONE) {
-            if (it == shader.maps.begin()) {
-                const int additive = aiBlendMode_Additive;
-                out->AddProperty(&additive, 1, AI_MATKEY_BLEND_FUNC);
-
-                index = cur_diffuse++;
-                type = aiTextureType_DIFFUSE;
-            } else {
-                index = cur_emissive++;
-                type = aiTextureType_EMISSIVE;
-            }
-        } else if ((*it).blend_src == Q3Shader::BLEND_GL_DST_COLOR && (*it).blend_dest == Q3Shader::BLEND_GL_ZERO) {
-            index = cur_lm++;
-            type = aiTextureType_LIGHTMAP;
-        } else {
-            const int blend = aiBlendMode_Default;
-            out->AddProperty(&blend, 1, AI_MATKEY_BLEND_FUNC);
-
-            index = cur_diffuse++;
-            type = aiTextureType_DIFFUSE;
-        }
-
-        // setup texture
-        out->AddProperty(&s, AI_MATKEY_TEXTURE(type, index));
-
-        // setup texture flags
-        const int use_alpha = ((*it).alpha_test != Q3Shader::AT_NONE ? aiTextureFlags_UseAlpha : aiTextureFlags_IgnoreAlpha);
-        out->AddProperty(&use_alpha, 1, AI_MATKEY_TEXFLAGS(type, index));
-    }
-    // If at least one emissive texture was set, set the emissive base color to 1 to ensure
-    // the texture is actually displayed.
-    if (0 != cur_emissive) {
-        aiColor3D one(1.f, 1.f, 1.f);
-        out->AddProperty(&one, 1, AI_MATKEY_COLOR_EMISSIVE);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-MD3Importer::MD3Importer() :
-        configFrameID(0), configHandleMP(true), configSpeedFlag(), pcHeader(), mBuffer(), fileSize(), mScene(), mIOHandler() {}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-MD3Importer::~MD3Importer() {}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool MD3Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    static const uint32_t tokens[] = { AI_MD3_MAGIC_NUMBER_LE };
-    return CheckMagicToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
-}
-
-// ------------------------------------------------------------------------------------------------
-void MD3Importer::ValidateHeaderOffsets() {
-    // Check magic number
-    if (pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_BE &&
-            pcHeader->IDENT != AI_MD3_MAGIC_NUMBER_LE)
-        throw DeadlyImportError("Invalid MD3 file: Magic bytes not found");
-
-    // Check file format version
-    if (pcHeader->VERSION > 15)
-        ASSIMP_LOG_WARN("Unsupported MD3 file version. Continuing happily ...");
-
-    // Check some offset values whether they are valid
-    if (!pcHeader->NUM_SURFACES)
-        throw DeadlyImportError("Invalid md3 file: NUM_SURFACES is 0");
-
-    if (pcHeader->OFS_FRAMES >= fileSize || pcHeader->OFS_SURFACES >= fileSize ||
-            pcHeader->OFS_EOF > fileSize) {
-        throw DeadlyImportError("Invalid MD3 header: some offsets are outside the file");
-    }
-
-    if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(MD3::Surface)) {
-        throw DeadlyImportError("Invalid MD3 header: too many surfaces, would overflow");
-    }
-
-    if (pcHeader->OFS_SURFACES + pcHeader->NUM_SURFACES * sizeof(MD3::Surface) >= fileSize) {
-        throw DeadlyImportError("Invalid MD3 header: some surfaces are outside the file");
-    }
-
-    if (pcHeader->NUM_FRAMES <= configFrameID)
-        throw DeadlyImportError("The requested frame is not existing the file");
-}
-
-// ------------------------------------------------------------------------------------------------
-void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface *pcSurf) {
-    // Calculate the relative offset of the surface
-    const int32_t ofs = int32_t((const unsigned char *)pcSurf - this->mBuffer);
-
-    // Check whether all data chunks are inside the valid range
-    if (pcSurf->OFS_TRIANGLES + ofs + pcSurf->NUM_TRIANGLES * sizeof(MD3::Triangle) > fileSize ||
-            pcSurf->OFS_SHADERS + ofs + pcSurf->NUM_SHADER * sizeof(MD3::Shader) > fileSize ||
-            pcSurf->OFS_ST + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::TexCoord) > fileSize ||
-            pcSurf->OFS_XYZNORMAL + ofs + pcSurf->NUM_VERTICES * sizeof(MD3::Vertex) > fileSize) {
-
-        throw DeadlyImportError("Invalid MD3 surface header: some offsets are outside the file");
-    }
-
-    // Check whether all requirements for Q3 files are met. We don't
-    // care, but probably someone does.
-    if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) {
-        ASSIMP_LOG_WARN("MD3: Quake III triangle limit exceeded");
-    }
-
-    if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) {
-        ASSIMP_LOG_WARN("MD3: Quake III shader limit exceeded");
-    }
-
-    if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) {
-        ASSIMP_LOG_WARN("MD3: Quake III vertex limit exceeded");
-    }
-
-    if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) {
-        ASSIMP_LOG_WARN("MD3: Quake III frame limit exceeded");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc *MD3Importer::GetInfo() const {
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties
-void MD3Importer::SetupProperties(const Importer *pImp) {
-    // The
-    // AI_CONFIG_IMPORT_MD3_KEYFRAME option overrides the
-    // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_KEYFRAME, -1);
-    if (static_cast<unsigned int>(-1) == configFrameID) {
-        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
-    }
-
-    // AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART
-    configHandleMP = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 1));
-
-    // AI_CONFIG_IMPORT_MD3_SKIN_NAME
-    configSkinFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SKIN_NAME, "default"));
-
-    // AI_CONFIG_IMPORT_MD3_LOAD_SHADERS
-    configLoadShaders = (pImp->GetPropertyBool(AI_CONFIG_IMPORT_MD3_LOAD_SHADERS, true));
-
-    // AI_CONFIG_IMPORT_MD3_SHADER_SRC
-    configShaderFile = (pImp->GetPropertyString(AI_CONFIG_IMPORT_MD3_SHADER_SRC, ""));
-
-    // AI_CONFIG_FAVOUR_SPEED
-    configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Try to read the skin for a MD3 file
-void MD3Importer::ReadSkin(Q3Shader::SkinData &fill) const {
-    // skip any postfixes (e.g. lower_1.md3)
-    std::string::size_type s = filename.find_last_of('_');
-    if (s == std::string::npos) {
-        s = filename.find_last_of('.');
-        if (s == std::string::npos) {
-            s = filename.size();
-        }
-    }
-    ai_assert(s != std::string::npos);
-
-    const std::string skin_file = path + filename.substr(0, s) + "_" + configSkinFile + ".skin";
-    Q3Shader::LoadSkin(fill, skin_file, mIOHandler);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Try to read the shader for a MD3 file
-void MD3Importer::ReadShader(Q3Shader::ShaderData &fill) const {
-    // Determine Q3 model name from given path
-    const std::string::size_type s = path.find_last_of("\\/", path.length() - 2);
-    const std::string model_file = path.substr(s + 1, path.length() - (s + 2));
-
-    // If no specific dir or file is given, use our default search behaviour
-    if (!configShaderFile.length()) {
-        const char sep = mIOHandler->getOsSeparator();
-        if (!Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + model_file + ".shader", mIOHandler)) {
-             Q3Shader::LoadShader(fill, path + ".." + sep + ".." + sep + ".." + sep + "scripts" + sep + filename + ".shader", mIOHandler);
-        }
-    } else {
-        // If the given string specifies a file, load this file.
-        // Otherwise it's a directory.
-        const std::string::size_type st = configShaderFile.find_last_of('.');
-        if (st == std::string::npos) {
-
-            if (!Q3Shader::LoadShader(fill, configShaderFile + model_file + ".shader", mIOHandler)) {
-                Q3Shader::LoadShader(fill, configShaderFile + filename + ".shader", mIOHandler);
-            }
-        } else {
-            Q3Shader::LoadShader(fill, configShaderFile, mIOHandler);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Tiny helper to remove a single node from its parent' list
-void RemoveSingleNodeFromList(aiNode *nd) {
-    if (!nd || nd->mNumChildren || !nd->mParent) return;
-    aiNode *par = nd->mParent;
-    for (unsigned int i = 0; i < par->mNumChildren; ++i) {
-        if (par->mChildren[i] == nd) {
-            --par->mNumChildren;
-            for (; i < par->mNumChildren; ++i) {
-                par->mChildren[i] = par->mChildren[i + 1];
-            }
-            delete nd;
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read a multi-part Q3 player model
-bool MD3Importer::ReadMultipartFile() {
-    // check whether the file name contains a common postfix, e.g lower_2.md3
-    std::string::size_type s = filename.find_last_of('_'), t = filename.find_last_of('.');
-
-    if (t == std::string::npos)
-        t = filename.size();
-    if (s == std::string::npos)
-        s = t;
-
-    const std::string mod_filename = filename.substr(0, s);
-    const std::string suffix = filename.substr(s, t - s);
-
-    if (mod_filename == "lower" || mod_filename == "upper" || mod_filename == "head") {
-        const std::string lower = path + "lower" + suffix + ".md3";
-        const std::string upper = path + "upper" + suffix + ".md3";
-        const std::string head = path + "head" + suffix + ".md3";
-
-        aiScene *scene_upper = nullptr;
-        aiScene *scene_lower = nullptr;
-        aiScene *scene_head = nullptr;
-        std::string failure;
-
-        aiNode *tag_torso, *tag_head;
-        std::vector<AttachmentInfo> attach;
-
-        ASSIMP_LOG_INFO("Multi part MD3 player model: lower, upper and head parts are joined");
-
-        // ensure we won't try to load ourselves recursively
-        BatchLoader::PropertyMap props;
-        SetGenericProperty(props.ints, AI_CONFIG_IMPORT_MD3_HANDLE_MULTIPART, 0);
-
-        // now read these three files
-        BatchLoader batch(mIOHandler);
-        const unsigned int _lower = batch.AddLoadRequest(lower, 0, &props);
-        const unsigned int _upper = batch.AddLoadRequest(upper, 0, &props);
-        const unsigned int _head = batch.AddLoadRequest(head, 0, &props);
-        batch.LoadAll();
-
-        // now construct a dummy scene to place these three parts in
-        aiScene *master = new aiScene();
-        aiNode *nd = master->mRootNode = new aiNode();
-        nd->mName.Set("<MD3_Player>");
-
-        // ... and get them. We need all of them.
-        scene_lower = batch.GetImport(_lower);
-        if (!scene_lower) {
-            ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, lower.md3 fails to load");
-            failure = "lower";
-            goto error_cleanup;
-        }
-
-        scene_upper = batch.GetImport(_upper);
-        if (!scene_upper) {
-            ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, upper.md3 fails to load");
-            failure = "upper";
-            goto error_cleanup;
-        }
-
-        scene_head = batch.GetImport(_head);
-        if (!scene_head) {
-            ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, head.md3 fails to load");
-            failure = "head";
-            goto error_cleanup;
-        }
-
-        // build attachment infos. search for typical Q3 tags
-
-        // original root
-        scene_lower->mRootNode->mName.Set("lower");
-        attach.push_back(AttachmentInfo(scene_lower, nd));
-
-        // tag_torso
-        tag_torso = scene_lower->mRootNode->FindNode("tag_torso");
-        if (!tag_torso) {
-            ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_torso expected");
-            goto error_cleanup;
-        }
-        scene_upper->mRootNode->mName.Set("upper");
-        attach.push_back(AttachmentInfo(scene_upper, tag_torso));
-
-        // tag_head
-        tag_head = scene_upper->mRootNode->FindNode("tag_head");
-        if (!tag_head) {
-            ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_head expected");
-            goto error_cleanup;
-        }
-        scene_head->mRootNode->mName.Set("head");
-        attach.push_back(AttachmentInfo(scene_head, tag_head));
-
-        // Remove tag_head and tag_torso from all other model parts ...
-        // this ensures (together with AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY)
-        // that tag_torso/tag_head is also the name of the (unique) output node
-        RemoveSingleNodeFromList(scene_upper->mRootNode->FindNode("tag_torso"));
-        RemoveSingleNodeFromList(scene_head->mRootNode->FindNode("tag_head"));
-
-        // Undo the rotations which we applied to the coordinate systems. We're
-        // working in global Quake space here
-        scene_head->mRootNode->mTransformation = aiMatrix4x4();
-        scene_lower->mRootNode->mTransformation = aiMatrix4x4();
-        scene_upper->mRootNode->mTransformation = aiMatrix4x4();
-
-        // and merge the scenes
-        SceneCombiner::MergeScenes(&mScene, master, attach,
-                AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES |
-                        AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES |
-                        AI_INT_MERGE_SCENE_RESOLVE_CROSS_ATTACHMENTS |
-                        (!configSpeedFlag ? AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY : 0));
-
-        // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-        mScene->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);
-
-        return true;
-
-    error_cleanup:
-        delete scene_upper;
-        delete scene_lower;
-        delete scene_head;
-        delete master;
-
-        if (failure == mod_filename) {
-            throw DeadlyImportError("MD3: failure to read multipart host file");
-        }
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Convert a MD3 path to a proper value
-void MD3Importer::ConvertPath(const char *texture_name, const char *header_name, std::string &out) const {
-    // If the MD3's internal path itself and the given path are using
-    // the same directory, remove it completely to get right output paths.
-    const char *end1 = ::strrchr(header_name, '\\');
-    if (!end1) end1 = ::strrchr(header_name, '/');
-
-    const char *end2 = ::strrchr(texture_name, '\\');
-    if (!end2) end2 = ::strrchr(texture_name, '/');
-
-    // HACK: If the paths starts with "models", ignore the
-    // next two hierarchy levels, it specifies just the model name.
-    // Ignored by Q3, it might be not equal to the real model location.
-    if (end2) {
-
-        size_t len2;
-        const size_t len1 = (size_t)(end1 - header_name);
-        if (!ASSIMP_strincmp(texture_name, "models", 6) && (texture_name[6] == '/' || texture_name[6] == '\\')) {
-            len2 = 6; // ignore the seventh - could be slash or backslash
-
-            if (!header_name[0]) {
-                // Use the file name only
-                out = end2 + 1;
-                return;
-            }
-        } else
-            len2 = std::min(len1, (size_t)(end2 - texture_name));
-        if (!ASSIMP_strincmp(texture_name, header_name, static_cast<unsigned int>(len2))) {
-            // Use the file name only
-            out = end2 + 1;
-            return;
-        }
-    }
-    // Use the full path
-    out = texture_name;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void MD3Importer::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
-    mFile = pFile;
-    mScene = pScene;
-    mIOHandler = pIOHandler;
-
-    // get base path and file name
-    // todo ... move to PathConverter
-    std::string::size_type s = mFile.find_last_of("/\\");
-    if (s == std::string::npos) {
-        s = 0;
-    } else {
-        ++s;
-    }
-    filename = mFile.substr(s), path = mFile.substr(0, s);
-    for (std::string::iterator it = filename.begin(); it != filename.end(); ++it) {
-        *it = static_cast<char>(tolower(static_cast<unsigned char>(*it)));
-    }
-
-    // Load multi-part model file, if necessary
-    if (configHandleMP) {
-        if (ReadMultipartFile())
-            return;
-    }
-
-    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
-
-    // Check whether we can read from the file
-    if (file.get() == nullptr) {
-        throw DeadlyImportError("Failed to open MD3 file ", pFile, ".");
-    }
-
-    // Check whether the md3 file is large enough to contain the header
-    fileSize = (unsigned int)file->FileSize();
-    if (fileSize < sizeof(MD3::Header))
-        throw DeadlyImportError("MD3 File is too small.");
-
-    // Allocate storage and copy the contents of the file to a memory buffer
-    std::vector<unsigned char> mBuffer2(fileSize);
-    file->Read(&mBuffer2[0], 1, fileSize);
-    mBuffer = &mBuffer2[0];
-
-    pcHeader = (BE_NCONST MD3::Header *)mBuffer;
-
-    // Ensure correct endianness
-#ifdef AI_BUILD_BIG_ENDIAN
-
-    AI_SWAP4(pcHeader->VERSION);
-    AI_SWAP4(pcHeader->FLAGS);
-    AI_SWAP4(pcHeader->IDENT);
-    AI_SWAP4(pcHeader->NUM_FRAMES);
-    AI_SWAP4(pcHeader->NUM_SKINS);
-    AI_SWAP4(pcHeader->NUM_SURFACES);
-    AI_SWAP4(pcHeader->NUM_TAGS);
-    AI_SWAP4(pcHeader->OFS_EOF);
-    AI_SWAP4(pcHeader->OFS_FRAMES);
-    AI_SWAP4(pcHeader->OFS_SURFACES);
-    AI_SWAP4(pcHeader->OFS_TAGS);
-
-#endif
-
-    // Validate the file header
-    ValidateHeaderOffsets();
-
-    // Navigate to the list of surfaces
-    BE_NCONST MD3::Surface *pcSurfaces = (BE_NCONST MD3::Surface *)(mBuffer + pcHeader->OFS_SURFACES);
-
-    // Navigate to the list of tags
-    BE_NCONST MD3::Tag *pcTags = (BE_NCONST MD3::Tag *)(mBuffer + pcHeader->OFS_TAGS);
-
-    // Allocate output storage
-    pScene->mNumMeshes = pcHeader->NUM_SURFACES;
-    if (pcHeader->NUM_SURFACES == 0) {
-        throw DeadlyImportError("MD3: No surfaces");
-    } else if (pcHeader->NUM_SURFACES > AI_MAX_ALLOC(aiMesh)) {
-        // We allocate pointers but check against the size of aiMesh
-        // since those pointers will eventually have to point to real objects
-        throw DeadlyImportError("MD3: Too many surfaces, would run out of memory");
-    }
-    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
-
-    pScene->mNumMaterials = pcHeader->NUM_SURFACES;
-    pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes];
-
-    // Set arrays to zero to ensue proper destruction if an exception is raised
-    ::memset(pScene->mMeshes, 0, pScene->mNumMeshes * sizeof(aiMesh *));
-    ::memset(pScene->mMaterials, 0, pScene->mNumMaterials * sizeof(aiMaterial *));
-
-    // Now read possible skins from .skin file
-    Q3Shader::SkinData skins;
-    ReadSkin(skins);
-
-    // And check whether we can locate a shader file for this model
-    Q3Shader::ShaderData shaders;
-    if (configLoadShaders){
-        ReadShader(shaders);
-    }
-
-    // Adjust all texture paths in the shader
-    const char *header_name = pcHeader->NAME;
-    if (!shaders.blocks.empty()) {
-        for (std::list<Q3Shader::ShaderDataBlock>::iterator dit = shaders.blocks.begin(); dit != shaders.blocks.end(); ++dit) {
-            ConvertPath((*dit).name.c_str(), header_name, (*dit).name);
-
-            for (std::list<Q3Shader::ShaderMapBlock>::iterator mit = (*dit).maps.begin(); mit != (*dit).maps.end(); ++mit) {
-                ConvertPath((*mit).name.c_str(), header_name, (*mit).name);
-            }
-        }
-    }
-
-    // Read all surfaces from the file
-    unsigned int iNum = pcHeader->NUM_SURFACES;
-    unsigned int iNumMaterials = 0;
-    while (iNum-- > 0) {
-
-        // Ensure correct endianness
-#ifdef AI_BUILD_BIG_ENDIAN
-
-        AI_SWAP4(pcSurfaces->FLAGS);
-        AI_SWAP4(pcSurfaces->IDENT);
-        AI_SWAP4(pcSurfaces->NUM_FRAMES);
-        AI_SWAP4(pcSurfaces->NUM_SHADER);
-        AI_SWAP4(pcSurfaces->NUM_TRIANGLES);
-        AI_SWAP4(pcSurfaces->NUM_VERTICES);
-        AI_SWAP4(pcSurfaces->OFS_END);
-        AI_SWAP4(pcSurfaces->OFS_SHADERS);
-        AI_SWAP4(pcSurfaces->OFS_ST);
-        AI_SWAP4(pcSurfaces->OFS_TRIANGLES);
-        AI_SWAP4(pcSurfaces->OFS_XYZNORMAL);
-
-#endif
-
-        // Validate the surface header
-        ValidateSurfaceHeaderOffsets(pcSurfaces);
-
-        // Navigate to the vertex list of the surface
-        BE_NCONST MD3::Vertex *pcVertices = (BE_NCONST MD3::Vertex *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_XYZNORMAL);
-
-        // Navigate to the triangle list of the surface
-        BE_NCONST MD3::Triangle *pcTriangles = (BE_NCONST MD3::Triangle *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_TRIANGLES);
-
-        // Navigate to the texture coordinate list of the surface
-        BE_NCONST MD3::TexCoord *pcUVs = (BE_NCONST MD3::TexCoord *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_ST);
-
-        // Navigate to the shader list of the surface
-        BE_NCONST MD3::Shader *pcShaders = (BE_NCONST MD3::Shader *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_SHADERS);
-
-        // If the submesh is empty ignore it
-        if (0 == pcSurfaces->NUM_VERTICES || 0 == pcSurfaces->NUM_TRIANGLES) {
-            pcSurfaces = (BE_NCONST MD3::Surface *)(((uint8_t *)pcSurfaces) + pcSurfaces->OFS_END);
-            pScene->mNumMeshes--;
-            continue;
-        }
-
-        // Allocate output mesh
-        pScene->mMeshes[iNum] = new aiMesh();
-        aiMesh *pcMesh = pScene->mMeshes[iNum];
-
-        std::string _texture_name;
-        const char *texture_name = nullptr;
-
-        // Check whether we have a texture record for this surface in the .skin file
-        std::list<Q3Shader::SkinData::TextureEntry>::iterator it = std::find(
-                skins.textures.begin(), skins.textures.end(), pcSurfaces->NAME);
-
-        if (it != skins.textures.end()) {
-            texture_name = &*(_texture_name = (*it).second).begin();
-            ASSIMP_LOG_VERBOSE_DEBUG("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME);
-            (*it).resolved = true; // mark entry as resolved
-        }
-
-        // Get the first shader (= texture?) assigned to the surface
-        if (!texture_name && pcSurfaces->NUM_SHADER) {
-            texture_name = pcShaders->NAME;
-        }
-
-        std::string convertedPath;
-        if (texture_name) {
-            if (configLoadShaders){
-                ConvertPath(texture_name, header_name, convertedPath);
-            }
-            else{
-                convertedPath = texture_name;
-            }
-        }
-
-        const Q3Shader::ShaderDataBlock *shader = nullptr;
-
-        // Now search the current shader for a record with this name (
-        // excluding texture file extension)
-        if (!shaders.blocks.empty()) {
-            std::string::size_type sh = convertedPath.find_last_of('.');
-            if (sh == std::string::npos) {
-                sh = convertedPath.length();
-            }
-
-            const std::string without_ext = convertedPath.substr(0, sh);
-            std::list<Q3Shader::ShaderDataBlock>::const_iterator dit = std::find(shaders.blocks.begin(), shaders.blocks.end(), without_ext);
-            if (dit != shaders.blocks.end()) {
-                // We made it!
-                shader = &*dit;
-                ASSIMP_LOG_INFO("Found shader record for ", without_ext);
-            } else {
-                ASSIMP_LOG_WARN("Unable to find shader record for ", without_ext);
-            }
-        }
-
-        aiMaterial *pcHelper = new aiMaterial();
-
-        const int iMode = (int)aiShadingMode_Gouraud;
-        pcHelper->AddProperty<int>(&iMode, 1, AI_MATKEY_SHADING_MODEL);
-
-        // Add a small ambient color value - Quake 3 seems to have one
-        aiColor3D clr;
-        clr.b = clr.g = clr.r = 0.05f;
-        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
-
-        clr.b = clr.g = clr.r = 1.0f;
-        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
-        pcHelper->AddProperty<aiColor3D>(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
-
-        // use surface name + skin_name as material name
-        aiString name;
-        name.Set("MD3_[" + configSkinFile + "][" + pcSurfaces->NAME + "]");
-        pcHelper->AddProperty(&name, AI_MATKEY_NAME);
-
-        if (!shader) {
-            // Setup dummy texture file name to ensure UV coordinates are kept during postprocessing
-            aiString szString;
-            if (convertedPath.length()) {
-                szString.Set(convertedPath);
-            } else {
-                ASSIMP_LOG_WARN("Texture file name has zero length. Using default name");
-                szString.Set("dummy_texture.bmp");
-            }
-            pcHelper->AddProperty(&szString, AI_MATKEY_TEXTURE_DIFFUSE(0));
-
-            // prevent transparency by default
-            int no_alpha = aiTextureFlags_IgnoreAlpha;
-            pcHelper->AddProperty(&no_alpha, 1, AI_MATKEY_TEXFLAGS_DIFFUSE(0));
-        } else {
-            Q3Shader::ConvertShaderToMaterial(pcHelper, *shader);
-        }
-
-        pScene->mMaterials[iNumMaterials] = (aiMaterial *)pcHelper;
-        pcMesh->mMaterialIndex = iNumMaterials++;
-
-        // Ensure correct endianness
-#ifdef AI_BUILD_BIG_ENDIAN
-
-        for (uint32_t i = 0; i < pcSurfaces->NUM_VERTICES; ++i) {
-            AI_SWAP2(pcVertices[i].NORMAL);
-            AI_SWAP2(pcVertices[i].X);
-            AI_SWAP2(pcVertices[i].Y);
-            AI_SWAP2(pcVertices[i].Z);
-
-            AI_SWAP4(pcUVs[i].U);
-            AI_SWAP4(pcUVs[i].V);
-        }
-        for (uint32_t i = 0; i < pcSurfaces->NUM_TRIANGLES; ++i) {
-            AI_SWAP4(pcTriangles[i].INDEXES[0]);
-            AI_SWAP4(pcTriangles[i].INDEXES[1]);
-            AI_SWAP4(pcTriangles[i].INDEXES[2]);
-        }
-
-#endif
-
-        // Fill mesh information
-        pcMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
-        pcMesh->mNumVertices = pcSurfaces->NUM_TRIANGLES * 3;
-        pcMesh->mNumFaces = pcSurfaces->NUM_TRIANGLES;
-        pcMesh->mFaces = new aiFace[pcSurfaces->NUM_TRIANGLES];
-        pcMesh->mNormals = new aiVector3D[pcMesh->mNumVertices];
-        pcMesh->mVertices = new aiVector3D[pcMesh->mNumVertices];
-        pcMesh->mTextureCoords[0] = new aiVector3D[pcMesh->mNumVertices];
-        pcMesh->mNumUVComponents[0] = 2;
-
-        // Fill in all triangles
-        unsigned int iCurrent = 0;
-        for (unsigned int i = 0; i < (unsigned int)pcSurfaces->NUM_TRIANGLES; ++i) {
-            pcMesh->mFaces[i].mIndices = new unsigned int[3];
-            pcMesh->mFaces[i].mNumIndices = 3;
-
-            //unsigned int iTemp = iCurrent;
-            for (unsigned int c = 0; c < 3; ++c, ++iCurrent) {
-                pcMesh->mFaces[i].mIndices[c] = iCurrent;
-
-                // Read vertices
-                aiVector3D &vec = pcMesh->mVertices[iCurrent];
-                uint32_t index = pcTriangles->INDEXES[c];
-                if (index >= pcSurfaces->NUM_VERTICES) {
-                    throw DeadlyImportError("MD3: Invalid vertex index");
-                }
-                vec.x = pcVertices[index].X * AI_MD3_XYZ_SCALE;
-                vec.y = pcVertices[index].Y * AI_MD3_XYZ_SCALE;
-                vec.z = pcVertices[index].Z * AI_MD3_XYZ_SCALE;
-
-                // Convert the normal vector to uncompressed float3 format
-                aiVector3D &nor = pcMesh->mNormals[iCurrent];
-                LatLngNormalToVec3(pcVertices[index].NORMAL, (ai_real *)&nor);
-
-                // Read texture coordinates
-                pcMesh->mTextureCoords[0][iCurrent].x = pcUVs[index].U;
-                pcMesh->mTextureCoords[0][iCurrent].y = 1.0f - pcUVs[index].V;
-            }
-            // Flip face order normally, unless shader is backfacing
-            if (!(shader && shader->cull == Q3Shader::CULL_CCW)) {
-                std::swap(pcMesh->mFaces[i].mIndices[2], pcMesh->mFaces[i].mIndices[1]);
-            }
-            ++pcTriangles;
-        }
-
-        // Go to the next surface
-        pcSurfaces = (BE_NCONST MD3::Surface *)(((unsigned char *)pcSurfaces) + pcSurfaces->OFS_END);
-    }
-
-    // For debugging purposes: check whether we found matches for all entries in the skins file
-    if (!DefaultLogger::isNullLogger()) {
-        for (std::list<Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin(); it != skins.textures.end(); ++it) {
-            if (!(*it).resolved) {
-                ASSIMP_LOG_ERROR("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second);
-            }
-        }
-    }
-
-    if (!pScene->mNumMeshes) {
-        throw DeadlyImportError("MD3: File contains no valid mesh");
-    }
-    pScene->mNumMaterials = iNumMaterials;
-
-    // Now we need to generate an empty node graph
-    pScene->mRootNode = new aiNode("<MD3Root>");
-    pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
-    pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
-
-    // Attach tiny children for all tags
-    if (pcHeader->NUM_TAGS) {
-        pScene->mRootNode->mNumChildren = pcHeader->NUM_TAGS;
-        pScene->mRootNode->mChildren = new aiNode *[pcHeader->NUM_TAGS];
-
-        for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) {
-            aiNode *nd = pScene->mRootNode->mChildren[i] = new aiNode();
-            nd->mName.Set((const char *)pcTags->NAME);
-            nd->mParent = pScene->mRootNode;
-
-            AI_SWAP4(pcTags->origin.x);
-            AI_SWAP4(pcTags->origin.y);
-            AI_SWAP4(pcTags->origin.z);
-
-            // Copy local origin, again flip z,y
-            nd->mTransformation.a4 = pcTags->origin.x;
-            nd->mTransformation.b4 = pcTags->origin.y;
-            nd->mTransformation.c4 = pcTags->origin.z;
-
-            // Copy rest of transformation (need to transpose to match row-order matrix)
-            for (unsigned int a = 0; a < 3; ++a) {
-                for (unsigned int m = 0; m < 3; ++m) {
-                    nd->mTransformation[m][a] = pcTags->orientation[a][m];
-                    AI_SWAP4(nd->mTransformation[m][a]);
-                }
-            }
-        }
-    }
-
-    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i)
-        pScene->mRootNode->mMeshes[i] = i;
-
-    // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-    pScene->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);
-}
-
-#endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER