delete src/mesh/assimp-master

1 files changed, 0 insertions, 1179 deletions

diff --git a/src/mesh/assimp-master/code/AssetLib/COB/COBLoader.cpp b/src/mesh/assimp-master/code/AssetLib/COB/COBLoader.cpp
deleted file mode 100644
index 1c83100..0000000
--- a/src/mesh/assimp-master/code/AssetLib/COB/COBLoader.cpp
+++ /dev/null
@@ -1,1179 +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  COBLoader.cpp
- *  @brief Implementation of the TrueSpace COB/SCN importer class.
- */
-
-#ifndef ASSIMP_BUILD_NO_COB_IMPORTER
-
-#include "AssetLib/COB/COBLoader.h"
-#include "AssetLib/COB/COBScene.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/LineSplitter.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/StreamReader.h>
-#include <assimp/TinyFormatter.h>
-#include <assimp/fast_atof.h>
-#include <assimp/importerdesc.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/IOSystem.hpp>
-
-#include <memory>
-
-using namespace Assimp;
-using namespace Assimp::COB;
-using namespace Assimp::Formatter;
-
-static const float units[] = {
-    1000.f,
-    100.f,
-    1.f,
-    0.001f,
-    1.f / 0.0254f,
-    1.f / 0.3048f,
-    1.f / 0.9144f,
-    1.f / 1609.344f
-};
-
-static const aiImporterDesc desc = {
-    "TrueSpace Object Importer",
-    "",
-    "",
-    "little-endian files only",
-    aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "cob scn"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-COBImporter::COBImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-COBImporter::~COBImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
-    static const char *tokens[] = { "Caligary" };
-    return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
-}
-
-// ------------------------------------------------------------------------------------------------
-// Loader meta information
-const aiImporterDesc *COBImporter::GetInfo() const {
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Setup configuration properties for the loader
-void COBImporter::SetupProperties(const Importer * /*pImp*/) {
-    // nothing to be done for the moment
-}
-
-// ------------------------------------------------------------------------------------------------
-/*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string &msg) {
-    throw DeadlyImportError("COB: ", msg);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
-    COB::Scene scene;
-
-    auto file = pIOHandler->Open(pFile, "rb");
-    if (!file) {
-        ThrowException("Could not open " + pFile);
-    }
-
-    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE(file));
-
-    // check header
-    char head[32];
-    stream->CopyAndAdvance(head, 32);
-    if (strncmp(head, "Caligari ", 9) != 0) {
-        ThrowException("Could not found magic id: `Caligari`");
-    }
-
-    ASSIMP_LOG_INFO("File format tag: ", std::string(head + 9, 6));
-    if (head[16] != 'L') {
-        ThrowException("File is big-endian, which is not supported");
-    }
-
-    // load data into intermediate structures
-    if (head[15] == 'A') {
-        ReadAsciiFile(scene, stream.get());
-    } else {
-        ReadBinaryFile(scene, stream.get());
-    }
-    if (scene.nodes.empty()) {
-        ThrowException("No nodes loaded");
-    }
-
-    // sort faces by material indices
-    for (std::shared_ptr<Node> &n : scene.nodes) {
-        if (n->type == Node::TYPE_MESH) {
-            Mesh &mesh = (Mesh &)(*n.get());
-            for (Face &f : mesh.faces) {
-                mesh.temp_map[f.material].push_back(&f);
-            }
-        }
-    }
-
-    // count meshes
-    for (std::shared_ptr<Node> &n : scene.nodes) {
-        if (n->type == Node::TYPE_MESH) {
-            Mesh &mesh = (Mesh &)(*n.get());
-            if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
-                pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size());
-            }
-        }
-    }
-    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
-    pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes]();
-    pScene->mNumMeshes = 0;
-
-    // count lights and cameras
-    for (std::shared_ptr<Node> &n : scene.nodes) {
-        if (n->type == Node::TYPE_LIGHT) {
-            ++pScene->mNumLights;
-        } else if (n->type == Node::TYPE_CAMERA) {
-            ++pScene->mNumCameras;
-        }
-    }
-
-    if (pScene->mNumLights) {
-        pScene->mLights = new aiLight *[pScene->mNumLights]();
-    }
-    if (pScene->mNumCameras) {
-        pScene->mCameras = new aiCamera *[pScene->mNumCameras]();
-    }
-    pScene->mNumLights = pScene->mNumCameras = 0;
-
-    // resolve parents by their IDs and build the output graph
-    std::unique_ptr<Node> root(new Group());
-    for (size_t n = 0; n < scene.nodes.size(); ++n) {
-        const Node &nn = *scene.nodes[n].get();
-        if (nn.parent_id == 0) {
-            root->temp_children.push_back(&nn);
-        }
-
-        for (size_t m = n; m < scene.nodes.size(); ++m) {
-            const Node &mm = *scene.nodes[m].get();
-            if (mm.parent_id == nn.id) {
-                nn.temp_children.push_back(&mm);
-            }
-        }
-    }
-
-    pScene->mRootNode = BuildNodes(*root.get(), scene, pScene);
-    //flip normals after import
-    FlipWindingOrderProcess flip;
-    flip.Execute(pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-void ConvertTexture(const std::shared_ptr<Texture> &tex, aiMaterial *out, aiTextureType type) {
-    const aiString path(tex->path);
-    out->AddProperty(&path, AI_MATKEY_TEXTURE(type, 0));
-    out->AddProperty(&tex->transform, 1, AI_MATKEY_UVTRANSFORM(type, 0));
-}
-
-// ------------------------------------------------------------------------------------------------
-aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fill) {
-    aiNode *nd = new aiNode();
-    nd->mName.Set(root.name);
-    nd->mTransformation = root.transform;
-
-    // Note to everybody believing Voodoo is appropriate here:
-    // I know polymorphism, run as fast as you can ;-)
-    if (Node::TYPE_MESH == root.type) {
-        const Mesh &ndmesh = (const Mesh &)(root);
-        if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) {
-
-            typedef std::pair<const unsigned int, Mesh::FaceRefList> Entry;
-            for (const Entry &reflist : ndmesh.temp_map) {
-                { // create mesh
-                    size_t n = 0;
-                    for (Face *f : reflist.second) {
-                        n += f->indices.size();
-                    }
-                    if (!n) {
-                        continue;
-                    }
-                    aiMesh *outmesh = fill->mMeshes[fill->mNumMeshes++] = new aiMesh();
-                    ++nd->mNumMeshes;
-
-                    outmesh->mVertices = new aiVector3D[n];
-                    outmesh->mTextureCoords[0] = new aiVector3D[n];
-
-                    outmesh->mFaces = new aiFace[reflist.second.size()]();
-                    for (Face *f : reflist.second) {
-                        if (f->indices.empty()) {
-                            continue;
-                        }
-
-                        aiFace &fout = outmesh->mFaces[outmesh->mNumFaces++];
-                        fout.mIndices = new unsigned int[f->indices.size()];
-
-                        for (VertexIndex &v : f->indices) {
-                            if (v.pos_idx >= ndmesh.vertex_positions.size()) {
-                                ThrowException("Position index out of range");
-                            }
-                            if (v.uv_idx >= ndmesh.texture_coords.size()) {
-                                ThrowException("UV index out of range");
-                            }
-                            outmesh->mVertices[outmesh->mNumVertices] = ndmesh.vertex_positions[v.pos_idx];
-                            outmesh->mTextureCoords[0][outmesh->mNumVertices] = aiVector3D(
-                                    ndmesh.texture_coords[v.uv_idx].x,
-                                    ndmesh.texture_coords[v.uv_idx].y,
-                                    0.f);
-
-                            fout.mIndices[fout.mNumIndices++] = outmesh->mNumVertices++;
-                        }
-                    }
-                    outmesh->mMaterialIndex = fill->mNumMaterials;
-                }
-                { // create material
-                    const Material *min = nullptr;
-                    for (const Material &m : scin.materials) {
-                        if (m.parent_id == ndmesh.id && m.matnum == reflist.first) {
-                            min = &m;
-                            break;
-                        }
-                    }
-                    std::unique_ptr<const Material> defmat;
-                    if (!min) {
-                        ASSIMP_LOG_VERBOSE_DEBUG("Could not resolve material index ", reflist.first, " - creating default material for this slot");
-
-                        defmat.reset(min = new Material());
-                    }
-
-                    aiMaterial *mat = new aiMaterial();
-                    fill->mMaterials[fill->mNumMaterials++] = mat;
-
-                    const aiString s(format("#mat_") << fill->mNumMeshes << "_" << min->matnum);
-                    mat->AddProperty(&s, AI_MATKEY_NAME);
-
-                    if (int tmp = ndmesh.draw_flags & Mesh::WIRED ? 1 : 0) {
-                        mat->AddProperty(&tmp, 1, AI_MATKEY_ENABLE_WIREFRAME);
-                    }
-
-                    {
-                        int shader;
-                        switch (min->shader) {
-                        case Material::FLAT:
-                            shader = aiShadingMode_Gouraud;
-                            break;
-
-                        case Material::PHONG:
-                            shader = aiShadingMode_Phong;
-                            break;
-
-                        case Material::METAL:
-                            shader = aiShadingMode_CookTorrance;
-                            break;
-
-                        default:
-                            ASSIMP_LOG_ERROR("Unknown option.");
-                            ai_assert(false); // shouldn't be here
-                            break;
-                        }
-                        mat->AddProperty(&shader, 1, AI_MATKEY_SHADING_MODEL);
-                        if (shader != aiShadingMode_Gouraud) {
-                            mat->AddProperty(&min->exp, 1, AI_MATKEY_SHININESS);
-                        }
-                    }
-
-                    mat->AddProperty(&min->ior, 1, AI_MATKEY_REFRACTI);
-                    mat->AddProperty(&min->rgb, 1, AI_MATKEY_COLOR_DIFFUSE);
-
-                    aiColor3D c = aiColor3D(min->rgb) * min->ks;
-                    mat->AddProperty(&c, 1, AI_MATKEY_COLOR_SPECULAR);
-
-                    c = aiColor3D(min->rgb) * min->ka;
-                    mat->AddProperty(&c, 1, AI_MATKEY_COLOR_AMBIENT);
-
-                    // convert textures if some exist.
-                    if (min->tex_color) {
-                        ConvertTexture(min->tex_color, mat, aiTextureType_DIFFUSE);
-                    }
-                    if (min->tex_env) {
-                        ConvertTexture(min->tex_env, mat, aiTextureType_UNKNOWN);
-                    }
-                    if (min->tex_bump) {
-                        ConvertTexture(min->tex_bump, mat, aiTextureType_HEIGHT);
-                    }
-                }
-            }
-        }
-    } else if (Node::TYPE_LIGHT == root.type) {
-        const Light &ndlight = (const Light &)(root);
-        aiLight *outlight = fill->mLights[fill->mNumLights++] = new aiLight();
-
-        outlight->mName.Set(ndlight.name);
-        outlight->mColorDiffuse = outlight->mColorAmbient = outlight->mColorSpecular = ndlight.color;
-
-        outlight->mAngleOuterCone = AI_DEG_TO_RAD(ndlight.angle);
-        outlight->mAngleInnerCone = AI_DEG_TO_RAD(ndlight.inner_angle);
-
-        // XXX
-        outlight->mType = ndlight.ltype == Light::SPOT ? aiLightSource_SPOT : aiLightSource_DIRECTIONAL;
-    } else if (Node::TYPE_CAMERA == root.type) {
-        const Camera &ndcam = (const Camera &)(root);
-        aiCamera *outcam = fill->mCameras[fill->mNumCameras++] = new aiCamera();
-
-        outcam->mName.Set(ndcam.name);
-    }
-
-    // add meshes
-    if (nd->mNumMeshes) { // mMeshes must be nullptr if count is 0
-        nd->mMeshes = new unsigned int[nd->mNumMeshes];
-        for (unsigned int i = 0; i < nd->mNumMeshes; ++i) {
-            nd->mMeshes[i] = fill->mNumMeshes - i - 1;
-        }
-    }
-
-    // add children recursively
-    nd->mChildren = new aiNode *[root.temp_children.size()]();
-    for (const Node *n : root.temp_children) {
-        (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n, scin, fill))->mParent = nd;
-    }
-
-    return nd;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Read an ASCII file into the given scene data structure
-void COBImporter::ReadAsciiFile(Scene &out, StreamReaderLE *stream) {
-    ChunkInfo ci;
-    for (LineSplitter splitter(*stream); splitter; ++splitter) {
-
-        // add all chunks to be recognized here. /else ../ omitted intentionally.
-        if (splitter.match_start("PolH ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadPolH_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("BitM ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadBitM_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Mat1 ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadMat1_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Grou ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadGrou_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Lght ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadLght_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Came ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadCame_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Bone ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadBone_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Chan ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadChan_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("Unit ")) {
-            ReadChunkInfo_Ascii(ci, splitter);
-            ReadUnit_Ascii(out, splitter, ci);
-        }
-        if (splitter.match_start("END ")) {
-            // we don't need this, but I guess there is a reason this
-            // chunk has been implemented into COB for.
-            return;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadChunkInfo_Ascii(ChunkInfo &out, const LineSplitter &splitter) {
-    const char *all_tokens[8];
-    splitter.get_tokens(all_tokens);
-
-    out.version = (all_tokens[1][1] - '0') * 100 + (all_tokens[1][3] - '0') * 10 + (all_tokens[1][4] - '0');
-    out.id = strtoul10(all_tokens[3]);
-    out.parent_id = strtoul10(all_tokens[5]);
-    out.size = strtol10(all_tokens[7]);
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::UnsupportedChunk_Ascii(LineSplitter &splitter, const ChunkInfo &nfo, const char *name) {
-    const std::string error = format("Encountered unsupported chunk: ") << name << " [version: " << nfo.version << ", size: " << nfo.size << "]";
-
-    // we can recover if the chunk size was specified.
-    if (nfo.size != static_cast<unsigned int>(-1)) {
-        ASSIMP_LOG_ERROR(error);
-
-        // (HACK) - our current position in the stream is the beginning of the
-        // head line of the next chunk. That's fine, but the caller is going
-        // to call ++ on `splitter`, which we need to swallow to avoid
-        // missing the next line.
-        splitter.get_stream().IncPtr(nfo.size);
-        splitter.swallow_next_increment();
-    } else {
-        ThrowException(error);
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBasicNodeInfo_Ascii(Node &msh, LineSplitter &splitter, const ChunkInfo & /*nfo*/) {
-    for (; splitter; ++splitter) {
-        if (splitter.match_start("Name")) {
-            msh.name = std::string(splitter[1]);
-
-            // make nice names by merging the dupe count
-            std::replace(msh.name.begin(), msh.name.end(),
-                    ',', '_');
-        } else if (splitter.match_start("Transform")) {
-            for (unsigned int y = 0; y < 4 && ++splitter; ++y) {
-                const char *s = splitter->c_str();
-                for (unsigned int x = 0; x < 4; ++x) {
-                    SkipSpaces(&s);
-                    msh.transform[y][x] = fast_atof(&s);
-                }
-            }
-            // we need the transform chunk, so we won't return until we have it.
-            return;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-template <typename T>
-void COBImporter::ReadFloat3Tuple_Ascii(T &fill, const char **in) {
-    const char *rgb = *in;
-    for (unsigned int i = 0; i < 3; ++i) {
-        SkipSpaces(&rgb);
-        if (*rgb == ',') ++rgb;
-        SkipSpaces(&rgb);
-
-        fill[i] = fast_atof(&rgb);
-    }
-    *in = rgb;
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadMat1_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Mat1");
-    }
-
-    ++splitter;
-    if (!splitter.match_start("mat# ")) {
-        ASSIMP_LOG_WARN("Expected `mat#` line in `Mat1` chunk ", nfo.id);
-        return;
-    }
-
-    out.materials.push_back(Material());
-    Material &mat = out.materials.back();
-    mat = nfo;
-
-    mat.matnum = strtoul10(splitter[1]);
-    ++splitter;
-
-    if (!splitter.match_start("shader: ")) {
-        ASSIMP_LOG_WARN("Expected `mat#` line in `Mat1` chunk ", nfo.id);
-        return;
-    }
-    std::string shader = std::string(splitter[1]);
-    shader = shader.substr(0, shader.find_first_of(" \t"));
-
-    if (shader == "metal") {
-        mat.shader = Material::METAL;
-    } else if (shader == "phong") {
-        mat.shader = Material::PHONG;
-    } else if (shader != "flat") {
-        ASSIMP_LOG_WARN("Unknown value for `shader` in `Mat1` chunk ", nfo.id);
-    }
-
-    ++splitter;
-    if (!splitter.match_start("rgb ")) {
-        ASSIMP_LOG_WARN("Expected `rgb` line in `Mat1` chunk ", nfo.id);
-    }
-
-    const char *rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(mat.rgb, &rgb);
-
-    ++splitter;
-    if (!splitter.match_start("alpha ")) {
-        ASSIMP_LOG_WARN("Expected `alpha` line in `Mat1` chunk ", nfo.id);
-    }
-
-    const char *tokens[10];
-    splitter.get_tokens(tokens);
-
-    mat.alpha = fast_atof(tokens[1]);
-    mat.ka = fast_atof(tokens[3]);
-    mat.ks = fast_atof(tokens[5]);
-    mat.exp = fast_atof(tokens[7]);
-    mat.ior = fast_atof(tokens[9]);
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadUnit_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Unit");
-    }
-    ++splitter;
-    if (!splitter.match_start("Units ")) {
-        ASSIMP_LOG_WARN("Expected `Units` line in `Unit` chunk ", nfo.id);
-        return;
-    }
-
-    // parent chunks preceede their children, so we should have the
-    // corresponding chunk already.
-    for (std::shared_ptr<Node> &nd : out.nodes) {
-        if (nd->id == nfo.parent_id) {
-            const unsigned int t = strtoul10(splitter[1]);
-
-            nd->unit_scale = t >= sizeof(units) / sizeof(units[0]) ? (
-                                                                             ASSIMP_LOG_WARN(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id), 1.f) :
-                                                                     units[t];
-            return;
-        }
-    }
-    ASSIMP_LOG_WARN("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadChan_Ascii(Scene & /*out*/, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Chan");
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadLght_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Lght");
-    }
-
-    out.nodes.push_back(std::shared_ptr<Light>(new Light()));
-    Light &msh = (Light &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
-
-    if (splitter.match_start("Infinite ")) {
-        msh.ltype = Light::INFINITE;
-    } else if (splitter.match_start("Local ")) {
-        msh.ltype = Light::LOCAL;
-    } else if (splitter.match_start("Spot ")) {
-        msh.ltype = Light::SPOT;
-    } else {
-        ASSIMP_LOG_WARN("Unknown kind of light source in `Lght` chunk ", nfo.id, " : ", *splitter);
-        msh.ltype = Light::SPOT;
-    }
-
-    ++splitter;
-    if (!splitter.match_start("color ")) {
-        ASSIMP_LOG_WARN("Expected `color` line in `Lght` chunk ", nfo.id);
-    }
-
-    const char *rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(msh.color, &rgb);
-
-    SkipSpaces(&rgb);
-    if (strncmp(rgb, "cone angle", 10) != 0) {
-        ASSIMP_LOG_WARN("Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id);
-    }
-    SkipSpaces(rgb + 10, &rgb);
-    msh.angle = fast_atof(&rgb);
-
-    SkipSpaces(&rgb);
-    if (strncmp(rgb, "inner angle", 11) != 0) {
-        ASSIMP_LOG_WARN("Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
-    }
-    SkipSpaces(rgb + 11, &rgb);
-    msh.inner_angle = fast_atof(&rgb);
-
-    // skip the rest for we can't handle this kind of physically-based lighting information.
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadCame_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 2) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Came");
-    }
-
-    out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
-    Camera &msh = (Camera &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
-
-    // skip the next line, we don't know this differentiation between a
-    // standard camera and a panoramic camera.
-    ++splitter;
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBone_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 5) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Bone");
-    }
-
-    out.nodes.push_back(std::shared_ptr<Bone>(new Bone()));
-    Bone &msh = (Bone &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
-
-    // TODO
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadGrou_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "Grou");
-    }
-
-    out.nodes.push_back(std::shared_ptr<Group>(new Group()));
-    Group &msh = (Group &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadPolH_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "PolH");
-    }
-
-    out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
-    Mesh &msh = (Mesh &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
-
-    // the chunk has a fixed order of components, but some are not interesting of us so
-    // we're just looking for keywords in arbitrary order. The end of the chunk is
-    // either the last `Face` or the `DrawFlags` attribute, depending on the format ver.
-    for (; splitter; ++splitter) {
-        if (splitter.match_start("World Vertices")) {
-            const unsigned int cnt = strtoul10(splitter[2]);
-            msh.vertex_positions.resize(cnt);
-
-            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
-                const char *s = splitter->c_str();
-
-                aiVector3D &v = msh.vertex_positions[cur];
-
-                SkipSpaces(&s);
-                v.x = fast_atof(&s);
-                SkipSpaces(&s);
-                v.y = fast_atof(&s);
-                SkipSpaces(&s);
-                v.z = fast_atof(&s);
-            }
-        } else if (splitter.match_start("Texture Vertices")) {
-            const unsigned int cnt = strtoul10(splitter[2]);
-            msh.texture_coords.resize(cnt);
-
-            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
-                const char *s = splitter->c_str();
-
-                aiVector2D &v = msh.texture_coords[cur];
-
-                SkipSpaces(&s);
-                v.x = fast_atof(&s);
-                SkipSpaces(&s);
-                v.y = fast_atof(&s);
-            }
-        } else if (splitter.match_start("Faces")) {
-            const unsigned int cnt = strtoul10(splitter[1]);
-            msh.faces.reserve(cnt);
-
-            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
-                if (splitter.match_start("Hole")) {
-                    ASSIMP_LOG_WARN("Skipping unsupported `Hole` line");
-                    continue;
-                }
-
-                if (!splitter.match_start("Face")) {
-                    ThrowException("Expected Face line");
-                }
-
-                msh.faces.push_back(Face());
-                Face &face = msh.faces.back();
-
-                face.indices.resize(strtoul10(splitter[2]));
-                face.flags = strtoul10(splitter[4]);
-                face.material = strtoul10(splitter[6]);
-
-                const char *s = (++splitter)->c_str();
-                for (size_t i = 0; i < face.indices.size(); ++i) {
-                    if (!SkipSpaces(&s)) {
-                        ThrowException("Expected EOL token in Face entry");
-                    }
-                    if ('<' != *s++) {
-                        ThrowException("Expected < token in Face entry");
-                    }
-                    face.indices[i].pos_idx = strtoul10(s, &s);
-                    if (',' != *s++) {
-                        ThrowException("Expected , token in Face entry");
-                    }
-                    face.indices[i].uv_idx = strtoul10(s, &s);
-                    if ('>' != *s++) {
-                        ThrowException("Expected < token in Face entry");
-                    }
-                }
-            }
-            if (nfo.version <= 4) {
-                break;
-            }
-        } else if (splitter.match_start("DrawFlags")) {
-            msh.draw_flags = strtoul10(splitter[1]);
-            break;
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBitM_Ascii(Scene & /*out*/, LineSplitter &splitter, const ChunkInfo &nfo) {
-    if (nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter, nfo, "BitM");
-    }
-
-    const unsigned int head = strtoul10((++splitter)[1]);
-    if (head != sizeof(Bitmap::BitmapHeader)) {
-        ASSIMP_LOG_WARN("Unexpected ThumbNailHdrSize, skipping this chunk");
-        return;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadString_Binary(std::string &out, StreamReaderLE &reader) {
-    out.resize(reader.GetI2());
-    for (char &c : out) {
-        c = reader.GetI1();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBasicNodeInfo_Binary(Node &msh, StreamReaderLE &reader, const ChunkInfo & /*nfo*/) {
-    const unsigned int dupes = reader.GetI2();
-    ReadString_Binary(msh.name, reader);
-
-    msh.name = format(msh.name) << '_' << dupes;
-
-    // skip local axes for the moment
-    reader.IncPtr(48);
-
-    msh.transform = aiMatrix4x4();
-    for (unsigned int y = 0; y < 3; ++y) {
-        for (unsigned int x = 0; x < 4; ++x) {
-            msh.transform[y][x] = reader.GetF4();
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::UnsupportedChunk_Binary(StreamReaderLE &reader, const ChunkInfo &nfo, const char *name) {
-    const std::string error = format("Encountered unsupported chunk: ") << name << " [version: " << nfo.version << ", size: " << nfo.size << "]";
-
-    // we can recover if the chunk size was specified.
-    if (nfo.size != static_cast<unsigned int>(-1)) {
-        ASSIMP_LOG_ERROR(error);
-        reader.IncPtr(nfo.size);
-    } else
-        ThrowException(error);
-}
-
-// ------------------------------------------------------------------------------------------------
-// tiny utility guard to aid me at staying within chunk boundaries.
-class chunk_guard {
-public:
-    chunk_guard(const COB::ChunkInfo &nfo, StreamReaderLE &reader) :
-            nfo(nfo), reader(reader), cur(reader.GetCurrentPos()) {
-        // empty
-    }
-
-    ~chunk_guard() {
-        // don't do anything if the size is not given
-        if (nfo.size != static_cast<unsigned int>(-1)) {
-            try {
-                reader.IncPtr(static_cast<int>(nfo.size) - reader.GetCurrentPos() + cur);
-            } catch (const DeadlyImportError &) {
-                // out of limit so correct the value
-                reader.IncPtr(reader.GetReadLimit());
-            }
-        }
-    }
-
-private:
-    const COB::ChunkInfo &nfo;
-    StreamReaderLE &reader;
-    long cur;
-};
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBinaryFile(Scene &out, StreamReaderLE *reader) {
-    if (nullptr == reader) {
-        return;
-    }
-
-    while (1) {
-        std::string type;
-        type += reader->GetI1();
-        type += reader->GetI1();
-        type += reader->GetI1();
-        type += reader->GetI1();
-
-        ChunkInfo nfo;
-        nfo.version = reader->GetI2() * 10;
-        nfo.version += reader->GetI2();
-
-        nfo.id = reader->GetI4();
-        nfo.parent_id = reader->GetI4();
-        nfo.size = reader->GetI4();
-
-        if (type == "PolH") {
-            ReadPolH_Binary(out, *reader, nfo);
-        } else if (type == "BitM") {
-            ReadBitM_Binary(out, *reader, nfo);
-        } else if (type == "Grou") {
-            ReadGrou_Binary(out, *reader, nfo);
-        } else if (type == "Lght") {
-            ReadLght_Binary(out, *reader, nfo);
-        } else if (type == "Came") {
-            ReadCame_Binary(out, *reader, nfo);
-        } else if (type == "Mat1") {
-            ReadMat1_Binary(out, *reader, nfo);
-        } else if (type == "Unit") {
-            ReadUnit_Binary(out, *reader, nfo);
-        } else if (type == "OLay") {
-            // ignore layer index silently.
-            if (nfo.size != static_cast<unsigned int>(-1)) {
-                reader->IncPtr(nfo.size);
-            } else
-                return UnsupportedChunk_Binary(*reader, nfo, type.c_str());
-        } else if (type == "END ") {
-            return;
-        } else {
-            UnsupportedChunk_Binary(*reader, nfo, type.c_str());
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadPolH_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 8) {
-        return UnsupportedChunk_Binary(reader, nfo, "PolH");
-    }
-    const chunk_guard cn(nfo, reader);
-
-    out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
-    Mesh &msh = (Mesh &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Binary(msh, reader, nfo);
-
-    msh.vertex_positions.resize(reader.GetI4());
-    for (aiVector3D &v : msh.vertex_positions) {
-        v.x = reader.GetF4();
-        v.y = reader.GetF4();
-        v.z = reader.GetF4();
-    }
-
-    msh.texture_coords.resize(reader.GetI4());
-    for (aiVector2D &v : msh.texture_coords) {
-        v.x = reader.GetF4();
-        v.y = reader.GetF4();
-    }
-
-    const size_t numf = reader.GetI4();
-    msh.faces.reserve(numf);
-    for (size_t i = 0; i < numf; ++i) {
-        // XXX backface culling flag is 0x10 in flags
-
-        // hole?
-        bool hole = (reader.GetI1() & 0x08) != 0;
-        if (hole) {
-            // XXX Basically this should just work fine - then triangulator
-            // should output properly triangulated data even for polygons
-            // with holes. Test data specific to COB is needed to confirm it.
-            if (msh.faces.empty()) {
-                ThrowException(format("A hole is the first entity in the `PolH` chunk with id ") << nfo.id);
-            }
-        } else
-            msh.faces.push_back(Face());
-        Face &f = msh.faces.back();
-
-        const size_t num = reader.GetI2();
-        f.indices.reserve(f.indices.size() + num);
-
-        if (!hole) {
-            f.material = reader.GetI2();
-            f.flags = 0;
-        }
-
-        for (size_t x = 0; x < num; ++x) {
-            f.indices.push_back(VertexIndex());
-
-            VertexIndex &v = f.indices.back();
-            v.pos_idx = reader.GetI4();
-            v.uv_idx = reader.GetI4();
-        }
-
-        if (hole) {
-            std::reverse(f.indices.rbegin(), f.indices.rbegin() + num);
-        }
-    }
-    if (nfo.version > 4) {
-        msh.draw_flags = reader.GetI4();
-    }
-    nfo.version > 5 && nfo.version < 8 ? reader.GetI4() : 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBitM_Binary(COB::Scene & /*out*/, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 1) {
-        return UnsupportedChunk_Binary(reader, nfo, "BitM");
-    }
-
-    const chunk_guard cn(nfo, reader);
-
-    const uint32_t len = reader.GetI4();
-    reader.IncPtr(len);
-
-    reader.GetI4();
-    reader.IncPtr(reader.GetI4());
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 8) {
-        return UnsupportedChunk_Binary(reader, nfo, "Mat1");
-    }
-
-    const chunk_guard cn(nfo, reader);
-
-    out.materials.push_back(Material());
-    Material &mat = out.materials.back();
-    mat = nfo;
-
-    mat.matnum = reader.GetI2();
-    switch (reader.GetI1()) {
-    case 'f':
-        mat.type = Material::FLAT;
-        break;
-    case 'p':
-        mat.type = Material::PHONG;
-        break;
-    case 'm':
-        mat.type = Material::METAL;
-        break;
-    default:
-        ASSIMP_LOG_ERROR("Unrecognized shader type in `Mat1` chunk with id ", nfo.id);
-        mat.type = Material::FLAT;
-    }
-
-    switch (reader.GetI1()) {
-    case 'f':
-        mat.autofacet = Material::FACETED;
-        break;
-    case 'a':
-        mat.autofacet = Material::AUTOFACETED;
-        break;
-    case 's':
-        mat.autofacet = Material::SMOOTH;
-        break;
-    default:
-        ASSIMP_LOG_ERROR("Unrecognized faceting mode in `Mat1` chunk with id ", nfo.id);
-        mat.autofacet = Material::FACETED;
-    }
-    mat.autofacet_angle = static_cast<float>(reader.GetI1());
-
-    mat.rgb.r = reader.GetF4();
-    mat.rgb.g = reader.GetF4();
-    mat.rgb.b = reader.GetF4();
-
-    mat.alpha = reader.GetF4();
-    mat.ka = reader.GetF4();
-    mat.ks = reader.GetF4();
-    mat.exp = reader.GetF4();
-    mat.ior = reader.GetF4();
-
-    char id[2];
-    id[0] = reader.GetI1(), id[1] = reader.GetI1();
-
-    if (id[0] == 'e' && id[1] == ':') {
-        mat.tex_env.reset(new Texture());
-
-        reader.GetI1();
-        ReadString_Binary(mat.tex_env->path, reader);
-
-        // advance to next texture-id
-        id[0] = reader.GetI1(), id[1] = reader.GetI1();
-    }
-
-    if (id[0] == 't' && id[1] == ':') {
-        mat.tex_color.reset(new Texture());
-
-        reader.GetI1();
-        ReadString_Binary(mat.tex_color->path, reader);
-
-        mat.tex_color->transform.mTranslation.x = reader.GetF4();
-        mat.tex_color->transform.mTranslation.y = reader.GetF4();
-
-        mat.tex_color->transform.mScaling.x = reader.GetF4();
-        mat.tex_color->transform.mScaling.y = reader.GetF4();
-
-        // advance to next texture-id
-        id[0] = reader.GetI1(), id[1] = reader.GetI1();
-    }
-
-    if (id[0] == 'b' && id[1] == ':') {
-        mat.tex_bump.reset(new Texture());
-
-        reader.GetI1();
-        ReadString_Binary(mat.tex_bump->path, reader);
-
-        mat.tex_bump->transform.mTranslation.x = reader.GetF4();
-        mat.tex_bump->transform.mTranslation.y = reader.GetF4();
-
-        mat.tex_bump->transform.mScaling.x = reader.GetF4();
-        mat.tex_bump->transform.mScaling.y = reader.GetF4();
-
-        // skip amplitude for I don't know its purpose.
-        reader.GetF4();
-    }
-    reader.IncPtr(-2);
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadCame_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader, nfo, "Came");
-    }
-
-    const chunk_guard cn(nfo, reader);
-
-    out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
-    Camera &msh = (Camera &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Binary(msh, reader, nfo);
-
-    // the rest is not interesting for us, so we skip over it.
-    if (nfo.version > 1) {
-        if (reader.GetI2() == 512) {
-            reader.IncPtr(42);
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadLght_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader, nfo, "Lght");
-    }
-
-    const chunk_guard cn(nfo, reader);
-
-    out.nodes.push_back(std::shared_ptr<Light>(new Light()));
-    Light &msh = (Light &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Binary(msh, reader, nfo);
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadGrou_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader, nfo, "Grou");
-    }
-
-    const chunk_guard cn(nfo, reader);
-
-    out.nodes.push_back(std::make_shared<Group>());
-    Group &msh = (Group &)(*out.nodes.back().get());
-    msh = nfo;
-
-    ReadBasicNodeInfo_Binary(msh, reader, nfo);
-}
-
-// ------------------------------------------------------------------------------------------------
-void COBImporter::ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
-    if (nfo.version > 1) {
-        return UnsupportedChunk_Binary(reader, nfo, "Unit");
-    }
-
-    const chunk_guard cn(nfo, reader);
-
-    // parent chunks preceede their children, so we should have the
-    // corresponding chunk already.
-    for (std::shared_ptr<Node> &nd : out.nodes) {
-        if (nd->id == nfo.parent_id) {
-            const unsigned int t = reader.GetI2();
-            nd->unit_scale = t >= sizeof(units) / sizeof(units[0]) ? (
-                                                                             ASSIMP_LOG_WARN(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id), 1.f) :
-                                                                     units[t];
-
-            return;
-        }
-    }
-    ASSIMP_LOG_WARN("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
-}
-
-#endif // ASSIMP_BUILD_NO_COB_IMPORTER