NvCloth 1.1.4 Release. (24070740)

1 files changed, 1300 insertions, 0 deletions

diff --git a/NvCloth/samples/external/assimp-4.1.0/code/COBLoader.cpp b/NvCloth/samples/external/assimp-4.1.0/code/COBLoader.cpp
new file mode 100644
index 0000000..a92e231
--- /dev/null
+++ b/NvCloth/samples/external/assimp-4.1.0/code/COBLoader.cpp
@@ -0,0 +1,1300 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2017, 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 "COBLoader.h"
+#include "COBScene.h"
+
+#include "StreamReader.h"
+#include "ParsingUtils.h"
+#include "fast_atof.h"
+
+#include "LineSplitter.h"
+#include "TinyFormatter.h"
+#include <memory>
+#include <assimp/IOSystem.hpp>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/scene.h>
+#include <assimp/importerdesc.h>
+
+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()
+{}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+COBImporter::~COBImporter()
+{}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool COBImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+{
+    const std::string& extension = GetExtension(pFile);
+    if (extension == "cob" || extension == "scn") {
+        return true;
+    }
+
+    else if ((!extension.length() || checkSig) && pIOHandler)   {
+        const char* tokens[] = {"Caligary"};
+        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+// 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;
+    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
+
+    // check header
+    char head[32];
+    stream->CopyAndAdvance(head,32);
+    if (strncmp(head,"Caligari ",9)) {
+        ThrowException("Could not found magic id: `Caligari`");
+    }
+
+    DefaultLogger::get()->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);
+}
+
+// ------------------------------------------------------------------------------------------------
+void ConvertTexture(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<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 = NULL;
+                    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) {
+                        DefaultLogger::get()->debug(format()<<"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:
+                            ai_assert(false); // shouldn't be here
+                        }
+                        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 NULL 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)) {
+        DefaultLogger::get()->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::LogWarn_Ascii(const LineSplitter& splitter, const format& message)    {
+    LogWarn_Ascii(message << " [at line "<< splitter.get_index()<<"]");
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogError_Ascii(const LineSplitter& splitter, const format& message)   {
+    LogError_Ascii(message << " [at line "<< splitter.get_index()<<"]");
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogInfo_Ascii(const LineSplitter& splitter, const format& message)    {
+    LogInfo_Ascii(message << " [at line "<< splitter.get_index()<<"]");
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogDebug_Ascii(const LineSplitter& splitter, const format& message)   {
+    LogDebug_Ascii(message << " [at line "<< splitter.get_index()<<"]");
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogWarn_Ascii(const Formatter::format& message)   {
+    DefaultLogger::get()->warn(std::string("COB: ")+=message);
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogError_Ascii(const Formatter::format& message)  {
+    DefaultLogger::get()->error(std::string("COB: ")+=message);
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogInfo_Ascii(const Formatter::format& message)   {
+    DefaultLogger::get()->info(std::string("COB: ")+=message);
+}
+
+// ------------------------------------------------------------------------------------------------
+void COBImporter::LogDebug_Ascii(const Formatter::format& message)  {
+    DefaultLogger::get()->debug(std::string("COB: ")+=message);
+}
+
+// ------------------------------------------------------------------------------------------------
+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# ")) {
+        LogWarn_Ascii(splitter,format()<<
+            "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: ")) {
+        LogWarn_Ascii(splitter,format()<<
+            "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") {
+        LogWarn_Ascii(splitter,format()<<
+            "Unknown value for `shader` in `Mat1` chunk "<<nfo.id);
+    }
+
+    ++splitter;
+    if (!splitter.match_start("rgb ")) {
+        LogWarn_Ascii(splitter,format()<<
+            "Expected `rgb` line in `Mat1` chunk "<<nfo.id);
+    }
+
+    const char* rgb = splitter[1];
+    ReadFloat3Tuple_Ascii(mat.rgb,&rgb);
+
+    ++splitter;
+    if (!splitter.match_start("alpha ")) {
+        LogWarn_Ascii(splitter,format()<<
+            "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 ")) {
+        LogWarn_Ascii(splitter,format()<<
+            "Expected `Units` line in `Unit` chunk "<<nfo.id);
+        return;
+    }
+
+    // parent chunks preceede their childs, 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])?(
+                LogWarn_Ascii(splitter,format()<<t<<" is not a valid value for `Units` attribute in `Unit chunk` "<<nfo.id)
+                ,1.f):units[t];
+            return;
+        }
+    }
+    LogWarn_Ascii(splitter,format()<<"`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 {
+        LogWarn_Ascii(splitter,format()<<
+            "Unknown kind of light source in `Lght` chunk "<<nfo.id<<" : "<<*splitter);
+        msh.ltype = Light::SPOT;
+    }
+
+    ++splitter;
+    if (!splitter.match_start("color ")) {
+        LogWarn_Ascii(splitter,format()<<
+            "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)) {
+        LogWarn_Ascii(splitter,format()<<
+            "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)) {
+        LogWarn_Ascii(splitter,format()<<
+            "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 differenciation 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")) {
+                    LogWarn_Ascii(splitter,"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");
+    }
+/*
+    "\nThumbNailHdrSize %ld"
+    "\nThumbHeader: %02hx 02hx %02hx "
+    "\nColorBufSize %ld"
+    "\nColorBufZipSize %ld"
+    "\nZippedThumbnail: %02hx 02hx %02hx "
+*/
+
+    const unsigned int head = strtoul10((++splitter)[1]);
+    if (head != sizeof(Bitmap::BitmapHeader)) {
+        LogWarn_Ascii(splitter,"Unexpected ThumbNailHdrSize, skipping this chunk");
+        return;
+    }
+
+    /*union {
+        Bitmap::BitmapHeader data;
+        char opaq[sizeof Bitmap::BitmapHeader()];
+    };*/
+//  ReadHexOctets(opaq,head,(++splitter)[1]);
+}
+
+// ------------------------------------------------------------------------------------------------
+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)) {
+        DefaultLogger::get()->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()) {
+    }
+
+    ~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 ( DeadlyImportError e ) {
+                // 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)
+{
+    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 == "Bone") {
+            ReadBone_Binary(out,*reader,nfo);
+        }
+        else if (type == "Chan") {
+            ReadChan_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;
+        if ((hole = (reader.GetI1() & 0x08) != 0)) {
+            // 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:
+            LogError_Ascii(format("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:
+            LogError_Ascii(format("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::shared_ptr<Group>(new 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 childs, 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])?(
+                LogWarn_Ascii(format()<<t<<" is not a valid value for `Units` attribute in `Unit chunk` "<<nfo.id)
+                ,1.f):units[t];
+
+            return;
+        }
+    }
+    LogWarn_Ascii(format()<<"`Unit` chunk "<<nfo.id<<" is a child of "
+        <<nfo.parent_id<<" which does not exist");
+}
+
+
+#endif