NvCloth 1.1.4 Release. (24070740)

1 files changed, 1276 insertions, 0 deletions

diff --git a/NvCloth/samples/external/assimp-4.1.0/code/NFFLoader.cpp b/NvCloth/samples/external/assimp-4.1.0/code/NFFLoader.cpp
new file mode 100644
index 0000000..a51c500
--- /dev/null
+++ b/NvCloth/samples/external/assimp-4.1.0/code/NFFLoader.cpp
@@ -0,0 +1,1276 @@
+/*
+---------------------------------------------------------------------------
+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 Implementation of the STL importer class */
+
+
+#ifndef ASSIMP_BUILD_NO_NFF_IMPORTER
+
+// internal headers
+#include "NFFLoader.h"
+#include "ParsingUtils.h"
+#include "StandardShapes.h"
+#include "qnan.h"
+#include "fast_atof.h"
+#include "RemoveComments.h"
+#include <assimp/IOSystem.hpp>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/scene.h>
+#include <assimp/importerdesc.h>
+#include <memory>
+
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+    "Neutral File Format Importer",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "enff nff"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+NFFImporter::NFFImporter()
+{}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+NFFImporter::~NFFImporter()
+{}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool NFFImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
+{
+    return SimpleExtensionCheck(pFile,"nff","enff");
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get the list of all supported file extensions
+const aiImporterDesc* NFFImporter::GetInfo () const
+{
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+#define AI_NFF_PARSE_FLOAT(f) \
+    SkipSpaces(&sz); \
+    if (!::IsLineEnd(*sz))sz = fast_atoreal_move<float>(sz, (float&)f);
+
+// ------------------------------------------------------------------------------------------------
+#define AI_NFF_PARSE_TRIPLE(v) \
+    AI_NFF_PARSE_FLOAT(v[0]) \
+    AI_NFF_PARSE_FLOAT(v[1]) \
+    AI_NFF_PARSE_FLOAT(v[2])
+
+// ------------------------------------------------------------------------------------------------
+#define AI_NFF_PARSE_SHAPE_INFORMATION() \
+    aiVector3D center, radius(1.0f,get_qnan(),get_qnan()); \
+    AI_NFF_PARSE_TRIPLE(center); \
+    AI_NFF_PARSE_TRIPLE(radius); \
+    if (is_qnan(radius.z))radius.z = radius.x; \
+    if (is_qnan(radius.y))radius.y = radius.x; \
+    currentMesh.radius = radius; \
+    currentMesh.center = center;
+
+// ------------------------------------------------------------------------------------------------
+#define AI_NFF2_GET_NEXT_TOKEN() \
+    do \
+    { \
+    if (!GetNextLine(buffer,line)) \
+        {DefaultLogger::get()->warn("NFF2: Unexpected EOF, can't read next token");break;} \
+    SkipSpaces(line,&sz); \
+    } \
+    while(IsLineEnd(*sz))
+
+
+// ------------------------------------------------------------------------------------------------
+// Loads the materail table for the NFF2 file format from an external file
+void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
+    const std::string& path, IOSystem* pIOHandler)
+{
+    std::unique_ptr<IOStream> file( pIOHandler->Open( path, "rb"));
+
+    // Check whether we can read from the file
+    if( !file.get())    {
+        DefaultLogger::get()->error("NFF2: Unable to open material library " + path + ".");
+        return;
+    }
+
+    // get the size of the file
+    const unsigned int m = (unsigned int)file->FileSize();
+
+    // allocate storage and copy the contents of the file to a memory buffer
+    // (terminate it with zero)
+    std::vector<char> mBuffer2(m+1);
+    TextFileToBuffer(file.get(),mBuffer2);
+    const char* buffer = &mBuffer2[0];
+
+    // First of all: remove all comments from the file
+    CommentRemover::RemoveLineComments("//",&mBuffer2[0]);
+
+    // The file should start with the magic sequence "mat"
+    if (!TokenMatch(buffer,"mat",3))    {
+        DefaultLogger::get()->error("NFF2: Not a valid material library " + path + ".");
+        return;
+    }
+
+    ShadingInfo* curShader = NULL;
+
+    // No read the file line per line
+    char line[4096];
+    const char* sz;
+    while (GetNextLine(buffer,line))
+    {
+        SkipSpaces(line,&sz);
+
+        // 'version' defines the version of the file format
+        if (TokenMatch(sz,"version",7))
+        {
+            DefaultLogger::get()->info("NFF (Sense8) material library file format: " + std::string(sz));
+        }
+        // 'matdef' starts a new material in the file
+        else if (TokenMatch(sz,"matdef",6))
+        {
+            // add a new material to the list
+            output.push_back( ShadingInfo() );
+            curShader = & output.back();
+
+            // parse the name of the material
+        }
+        else if (!TokenMatch(sz,"valid",5))
+        {
+            // check whether we have an active material at the moment
+            if (!IsLineEnd(*sz))
+            {
+                if (!curShader)
+                {
+                    DefaultLogger::get()->error(std::string("NFF2 material library: Found element ") +
+                        sz + "but there is no active material");
+                    continue;
+                }
+            }
+            else continue;
+
+            // now read the material property and determine its type
+            aiColor3D c;
+            if (TokenMatch(sz,"ambient",7))
+            {
+                AI_NFF_PARSE_TRIPLE(c);
+                curShader->ambient = c;
+            }
+            else if (TokenMatch(sz,"diffuse",7) || TokenMatch(sz,"ambientdiffuse",14) /* correct? */)
+            {
+                AI_NFF_PARSE_TRIPLE(c);
+                curShader->diffuse = curShader->ambient = c;
+            }
+            else if (TokenMatch(sz,"specular",8))
+            {
+                AI_NFF_PARSE_TRIPLE(c);
+                curShader->specular = c;
+            }
+            else if (TokenMatch(sz,"emission",8))
+            {
+                AI_NFF_PARSE_TRIPLE(c);
+                curShader->emissive = c;
+            }
+            else if (TokenMatch(sz,"shininess",9))
+            {
+                AI_NFF_PARSE_FLOAT(curShader->shininess);
+            }
+            else if (TokenMatch(sz,"opacity",7))
+            {
+                AI_NFF_PARSE_FLOAT(curShader->opacity);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void NFFImporter::InternReadFile( const std::string& pFile,
+    aiScene* pScene, IOSystem* pIOHandler)
+{
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+
+    // Check whether we can read from the file
+    if( !file.get())
+        throw DeadlyImportError( "Failed to open NFF file " + pFile + ".");
+
+    // allocate storage and copy the contents of the file to a memory buffer
+    // (terminate it with zero)
+    std::vector<char> mBuffer2;
+    TextFileToBuffer(file.get(),mBuffer2);
+    const char* buffer = &mBuffer2[0];
+
+    // mesh arrays - separate here to make the handling of the pointers below easier.
+    std::vector<MeshInfo> meshes;
+    std::vector<MeshInfo> meshesWithNormals;
+    std::vector<MeshInfo> meshesWithUVCoords;
+    std::vector<MeshInfo> meshesLocked;
+
+    char line[4096];
+    const char* sz;
+
+    // camera parameters
+    aiVector3D camPos, camUp(0.f,1.f,0.f), camLookAt(0.f,0.f,1.f);
+    float angle = 45.f;
+    aiVector2D resolution;
+
+    bool hasCam = false;
+
+    MeshInfo* currentMeshWithNormals = NULL;
+    MeshInfo* currentMesh = NULL;
+    MeshInfo* currentMeshWithUVCoords = NULL;
+
+    ShadingInfo s; // current material info
+
+    // degree of tesselation
+    unsigned int iTesselation = 4;
+
+    // some temporary variables we need to parse the file
+    unsigned int sphere     = 0,
+        cylinder            = 0,
+        cone                = 0,
+        numNamed            = 0,
+        dodecahedron        = 0,
+        octahedron          = 0,
+        tetrahedron         = 0,
+        hexahedron          = 0;
+
+    // lights imported from the file
+    std::vector<Light> lights;
+
+    // check whether this is the NFF2 file format
+    if (TokenMatch(buffer,"nff",3))
+    {
+        const float qnan = get_qnan();
+        const aiColor4D  cQNAN = aiColor4D (qnan,0.f,0.f,1.f);
+        const aiVector3D vQNAN = aiVector3D(qnan,0.f,0.f);
+
+        // another NFF file format ... just a raw parser has been implemented
+        // no support for further details, I don't think it is worth the effort
+        // http://ozviz.wasp.uwa.edu.au/~pbourke/dataformats/nff/nff2.html
+        // http://www.netghost.narod.ru/gff/graphics/summary/sense8.htm
+
+        // First of all: remove all comments from the file
+        CommentRemover::RemoveLineComments("//",&mBuffer2[0]);
+
+        while (GetNextLine(buffer,line))
+        {
+            SkipSpaces(line,&sz);
+            if (TokenMatch(sz,"version",7))
+            {
+                DefaultLogger::get()->info("NFF (Sense8) file format: " + std::string(sz));
+            }
+            else if (TokenMatch(sz,"viewpos",7))
+            {
+                AI_NFF_PARSE_TRIPLE(camPos);
+                hasCam = true;
+            }
+            else if (TokenMatch(sz,"viewdir",7))
+            {
+                AI_NFF_PARSE_TRIPLE(camLookAt);
+                hasCam = true;
+            }
+            // This starts a new object section
+            else if (!IsSpaceOrNewLine(*sz))
+            {
+                unsigned int subMeshIdx = 0;
+
+                // read the name of the object, skip all spaces
+                // at the end of it.
+                const char* sz3 = sz;
+                while (!IsSpaceOrNewLine(*sz))++sz;
+                std::string objectName = std::string(sz3,(unsigned int)(sz-sz3));
+
+                const unsigned int objStart = (unsigned int)meshes.size();
+
+                // There could be a material table in a separate file
+                std::vector<ShadingInfo> materialTable;
+                while (true)
+                {
+                    AI_NFF2_GET_NEXT_TOKEN();
+
+                    // material table - an external file
+                    if (TokenMatch(sz,"mtable",6))
+                    {
+                        SkipSpaces(&sz);
+                        sz3 = sz;
+                        while (!IsSpaceOrNewLine(*sz))++sz;
+                        const unsigned int diff = (unsigned int)(sz-sz3);
+                        if (!diff)DefaultLogger::get()->warn("NFF2: Found empty mtable token");
+                        else
+                        {
+                            // The material table has the file extension .mat.
+                            // If it is not there, we need to append it
+                            std::string path = std::string(sz3,diff);
+                            if(std::string::npos == path.find_last_of(".mat"))
+                            {
+                                path.append(".mat");
+                            }
+
+                            // Now extract the working directory from the path to
+                            // this file and append the material library filename
+                            // to it.
+                            std::string::size_type s;
+                            if ((std::string::npos == (s = path.find_last_of('\\')) || !s) &&
+                                (std::string::npos == (s = path.find_last_of('/'))  || !s) )
+                            {
+                                s = pFile.find_last_of('\\');
+                                if (std::string::npos == s)s = pFile.find_last_of('/');
+                                if (std::string::npos != s)
+                                {
+                                    path = pFile.substr(0,s+1) + path;
+                                }
+                            }
+                            LoadNFF2MaterialTable(materialTable,path,pIOHandler);
+                        }
+                    }
+                    else break;
+                }
+
+                // read the numbr of vertices
+                unsigned int num = ::strtoul10(sz,&sz);
+
+                // temporary storage
+                std::vector<aiColor4D>  tempColors;
+                std::vector<aiVector3D> tempPositions,tempTextureCoords,tempNormals;
+
+                bool hasNormals = false,hasUVs = false,hasColor = false;
+
+                tempPositions.reserve      (num);
+                tempColors.reserve         (num);
+                tempNormals.reserve        (num);
+                tempTextureCoords.reserve  (num);
+                for (unsigned int i = 0; i < num; ++i)
+                {
+                    AI_NFF2_GET_NEXT_TOKEN();
+                    aiVector3D v;
+                    AI_NFF_PARSE_TRIPLE(v);
+                    tempPositions.push_back(v);
+
+                    // parse all other attributes in the line
+                    while (true)
+                    {
+                        SkipSpaces(&sz);
+                        if (IsLineEnd(*sz))break;
+
+                        // color definition
+                        if (TokenMatch(sz,"0x",2))
+                        {
+                            hasColor = true;
+                            unsigned int numIdx = ::strtoul16(sz,&sz);
+                            aiColor4D clr;
+                            clr.a = 1.f;
+
+                            // 0xRRGGBB
+                            clr.r = ((numIdx >> 16u) & 0xff) / 255.f;
+                            clr.g = ((numIdx >> 8u)  & 0xff) / 255.f;
+                            clr.b = ((numIdx)        & 0xff) / 255.f;
+                            tempColors.push_back(clr);
+                        }
+                        // normal vector
+                        else if (TokenMatch(sz,"norm",4))
+                        {
+                            hasNormals = true;
+                            AI_NFF_PARSE_TRIPLE(v);
+                            tempNormals.push_back(v);
+                        }
+                        // UV coordinate
+                        else if (TokenMatch(sz,"uv",2))
+                        {
+                            hasUVs = true;
+                            AI_NFF_PARSE_FLOAT(v.x);
+                            AI_NFF_PARSE_FLOAT(v.y);
+                            v.z = 0.f;
+                            tempTextureCoords.push_back(v);
+                        }
+                    }
+
+                    // fill in dummies for all attributes that have not been set
+                    if (tempNormals.size() != tempPositions.size())
+                        tempNormals.push_back(vQNAN);
+
+                    if (tempTextureCoords.size() != tempPositions.size())
+                        tempTextureCoords.push_back(vQNAN);
+
+                    if (tempColors.size() != tempPositions.size())
+                        tempColors.push_back(cQNAN);
+                }
+
+                AI_NFF2_GET_NEXT_TOKEN();
+                if (!num)throw DeadlyImportError("NFF2: There are zero vertices");
+                num = ::strtoul10(sz,&sz);
+
+                std::vector<unsigned int> tempIdx;
+                tempIdx.reserve(10);
+                for (unsigned int i = 0; i < num; ++i)
+                {
+                    AI_NFF2_GET_NEXT_TOKEN();
+                    SkipSpaces(line,&sz);
+                    unsigned int numIdx = ::strtoul10(sz,&sz);
+
+                    // read all faces indices
+                    if (numIdx)
+                    {
+                        // mesh.faces.push_back(numIdx);
+                        // tempIdx.erase(tempIdx.begin(),tempIdx.end());
+                        tempIdx.resize(numIdx);
+
+                        for (unsigned int a = 0; a < numIdx;++a)
+                        {
+                            SkipSpaces(sz,&sz);
+                            unsigned int m = ::strtoul10(sz,&sz);
+                            if (m >= (unsigned int)tempPositions.size())
+                            {
+                                DefaultLogger::get()->error("NFF2: Vertex index overflow");
+                                m= 0;
+                            }
+                            // mesh.vertices.push_back (tempPositions[idx]);
+                            tempIdx[a] = m;
+                        }
+                    }
+
+                    // build a temporary shader object for the face.
+                    ShadingInfo shader;
+                    unsigned int matIdx = 0;
+
+                    // white material color - we have vertex colors
+                    shader.color = aiColor3D(1.f,1.f,1.f);
+                    aiColor4D c  = aiColor4D(1.f,1.f,1.f,1.f);
+                    while (true)
+                    {
+                        SkipSpaces(sz,&sz);
+                        if(IsLineEnd(*sz))break;
+
+                        // per-polygon colors
+                        if (TokenMatch(sz,"0x",2))
+                        {
+                            hasColor = true;
+                            const char* sz2 = sz;
+                            numIdx = ::strtoul16(sz,&sz);
+                            const unsigned int diff = (unsigned int)(sz-sz2);
+
+                            // 0xRRGGBB
+                            if (diff > 3)
+                            {
+                                c.r = ((numIdx >> 16u) & 0xff) / 255.f;
+                                c.g = ((numIdx >> 8u)  & 0xff) / 255.f;
+                                c.b = ((numIdx)        & 0xff) / 255.f;
+                            }
+                            // 0xRGB
+                            else
+                            {
+                                c.r = ((numIdx >> 8u) & 0xf) / 16.f;
+                                c.g = ((numIdx >> 4u) & 0xf) / 16.f;
+                                c.b = ((numIdx)       & 0xf) / 16.f;
+                            }
+                        }
+                        // TODO - implement texture mapping here
+#if 0
+                        // mirror vertex texture coordinate?
+                        else if (TokenMatch(sz,"mirror",6))
+                        {
+                        }
+                        // texture coordinate scaling
+                        else if (TokenMatch(sz,"scale",5))
+                        {
+                        }
+                        // texture coordinate translation
+                        else if (TokenMatch(sz,"trans",5))
+                        {
+                        }
+                        // texture coordinate rotation angle
+                        else if (TokenMatch(sz,"rot",3))
+                        {
+                        }
+#endif
+
+                        // texture file name for this polygon + mapping information
+                        else if ('_' == sz[0])
+                        {
+                            // get mapping information
+                            switch (sz[1])
+                            {
+                            case 'v':
+                            case 'V':
+
+                                shader.shaded = false;
+                                break;
+
+                            case 't':
+                            case 'T':
+                            case 'u':
+                            case 'U':
+
+                                DefaultLogger::get()->warn("Unsupported NFF2 texture attribute: trans");
+                            };
+                            if (!sz[1] || '_' != sz[2])
+                            {
+                                DefaultLogger::get()->warn("NFF2: Expected underscore after texture attributes");
+                                continue;
+                            }
+                            const char* sz2 = sz+3;
+                            while (!IsSpaceOrNewLine( *sz ))++sz;
+                            const unsigned int diff = (unsigned int)(sz-sz2);
+                            if (diff)shader.texFile = std::string(sz2,diff);
+                        }
+
+                        // Two-sided material?
+                        else if (TokenMatch(sz,"both",4))
+                        {
+                            shader.twoSided = true;
+                        }
+
+                        // Material ID?
+                        else if (!materialTable.empty() && TokenMatch(sz,"matid",5))
+                        {
+                            SkipSpaces(&sz);
+                            matIdx = ::strtoul10(sz,&sz);
+                            if (matIdx >= materialTable.size())
+                            {
+                                DefaultLogger::get()->error("NFF2: Material index overflow.");
+                                matIdx = 0;
+                            }
+
+                            // now combine our current shader with the shader we
+                            // read from the material table.
+                            ShadingInfo& mat = materialTable[matIdx];
+                            shader.ambient   = mat.ambient;
+                            shader.diffuse   = mat.diffuse;
+                            shader.emissive  = mat.emissive;
+                            shader.opacity   = mat.opacity;
+                            shader.specular  = mat.specular;
+                            shader.shininess = mat.shininess;
+                        }
+                        else SkipToken(sz);
+                    }
+
+                    // search the list of all shaders we have for this object whether
+                    // there is an identical one. In this case, we append our mesh
+                    // data to it.
+                    MeshInfo* mesh = NULL;
+                    for (std::vector<MeshInfo>::iterator it = meshes.begin() + objStart, end = meshes.end();
+                         it != end; ++it)
+                    {
+                        if ((*it).shader == shader && (*it).matIndex == matIdx)
+                        {
+                            // we have one, we can append our data to it
+                            mesh = &(*it);
+                        }
+                    }
+                    if (!mesh)
+                    {
+                        meshes.push_back(MeshInfo(PatchType_Simple,false));
+                        mesh = &meshes.back();
+                        mesh->matIndex = matIdx;
+
+                        // We need to add a new mesh to the list. We assign
+                        // an unique name to it to make sure the scene will
+                        // pass the validation step for the moment.
+                        // TODO: fix naming of objects in the scenegraph later
+                        if (objectName.length())
+                        {
+                            ::strcpy(mesh->name,objectName.c_str());
+                            ASSIMP_itoa10(&mesh->name[objectName.length()],30,subMeshIdx++);
+                        }
+
+                        // copy the shader to the mesh.
+                        mesh->shader = shader;
+                    }
+
+                    // fill the mesh with data
+                    if (!tempIdx.empty())
+                    {
+                        mesh->faces.push_back((unsigned int)tempIdx.size());
+                        for (std::vector<unsigned int>::const_iterator it = tempIdx.begin(), end = tempIdx.end();
+                            it != end;++it)
+                        {
+                            unsigned int m = *it;
+
+                            // copy colors -vertex color specifications override polygon color specifications
+                            if (hasColor)
+                            {
+                                const aiColor4D& clr = tempColors[m];
+                                mesh->colors.push_back((is_qnan( clr.r ) ? c : clr));
+                            }
+
+                            // positions should always be there
+                            mesh->vertices.push_back (tempPositions[m]);
+
+                            // copy normal vectors
+                            if (hasNormals)
+                                mesh->normals.push_back  (tempNormals[m]);
+
+                            // copy texture coordinates
+                            if (hasUVs)
+                                mesh->uvs.push_back      (tempTextureCoords[m]);
+                        }
+                    }
+                }
+                if (!num)throw DeadlyImportError("NFF2: There are zero faces");
+            }
+        }
+        camLookAt = camLookAt + camPos;
+    }
+    else // "Normal" Neutral file format that is quite more common
+    {
+        while (GetNextLine(buffer,line))
+        {
+            sz = line;
+            if ('p' == line[0] || TokenMatch(sz,"tpp",3))
+            {
+                MeshInfo* out = NULL;
+
+                // 'tpp' - texture polygon patch primitive
+                if ('t' == line[0])
+                {
+                    currentMeshWithUVCoords = NULL;
+                    for (auto &mesh : meshesWithUVCoords)
+                    {
+                        if (mesh.shader == s)
+                        {
+                            currentMeshWithUVCoords = &mesh;
+                            break;
+                        }
+                    }
+
+                    if (!currentMeshWithUVCoords)
+                    {
+                        meshesWithUVCoords.push_back(MeshInfo(PatchType_UVAndNormals));
+                        currentMeshWithUVCoords = &meshesWithUVCoords.back();
+                        currentMeshWithUVCoords->shader = s;
+                    }
+                    out = currentMeshWithUVCoords;
+                }
+                // 'pp' - polygon patch primitive
+                else if ('p' == line[1])
+                {
+                    currentMeshWithNormals = NULL;
+                    for (auto &mesh : meshesWithNormals)
+                    {
+                        if (mesh.shader == s)
+                        {
+                            currentMeshWithNormals = &mesh;
+                            break;
+                        }
+                    }
+
+                    if (!currentMeshWithNormals)
+                    {
+                        meshesWithNormals.push_back(MeshInfo(PatchType_Normals));
+                        currentMeshWithNormals = &meshesWithNormals.back();
+                        currentMeshWithNormals->shader = s;
+                    }
+                    sz = &line[2];out = currentMeshWithNormals;
+                }
+                // 'p' - polygon primitive
+                else
+                {
+                    currentMesh = NULL;
+                    for (auto &mesh : meshes)
+                    {
+                        if (mesh.shader == s)
+                        {
+                            currentMesh = &mesh;
+                            break;
+                        }
+                    }
+
+                    if (!currentMesh)
+                    {
+                        meshes.push_back(MeshInfo(PatchType_Simple));
+                        currentMesh = &meshes.back();
+                        currentMesh->shader = s;
+                    }
+                    sz = &line[1];out = currentMesh;
+                }
+                SkipSpaces(sz,&sz);
+                unsigned int m = strtoul10(sz);
+
+                // ---- flip the face order
+                out->vertices.resize(out->vertices.size()+m);
+                if (out != currentMesh)
+                {
+                    out->normals.resize(out->vertices.size());
+                }
+                if (out == currentMeshWithUVCoords)
+                {
+                    out->uvs.resize(out->vertices.size());
+                }
+                for (unsigned int n = 0; n < m;++n)
+                {
+                    if(!GetNextLine(buffer,line))
+                    {
+                        DefaultLogger::get()->error("NFF: Unexpected EOF was encountered. Patch definition incomplete");
+                        continue;
+                    }
+
+                    aiVector3D v; sz = &line[0];
+                    AI_NFF_PARSE_TRIPLE(v);
+                    out->vertices[out->vertices.size()-n-1] = v;
+
+                    if (out != currentMesh)
+                    {
+                        AI_NFF_PARSE_TRIPLE(v);
+                        out->normals[out->vertices.size()-n-1] = v;
+                    }
+                    if (out == currentMeshWithUVCoords)
+                    {
+                        // FIX: in one test file this wraps over multiple lines
+                        SkipSpaces(&sz);
+                        if (IsLineEnd(*sz))
+                        {
+                            GetNextLine(buffer,line);
+                            sz = line;
+                        }
+                        AI_NFF_PARSE_FLOAT(v.x);
+                        SkipSpaces(&sz);
+                        if (IsLineEnd(*sz))
+                        {
+                            GetNextLine(buffer,line);
+                            sz = line;
+                        }
+                        AI_NFF_PARSE_FLOAT(v.y);
+                        v.y = 1.f - v.y;
+                        out->uvs[out->vertices.size()-n-1] = v;
+                    }
+                }
+                out->faces.push_back(m);
+            }
+            // 'f' - shading information block
+            else if (TokenMatch(sz,"f",1))
+            {
+                float d;
+
+                // read the RGB colors
+                AI_NFF_PARSE_TRIPLE(s.color);
+
+                // read the other properties
+                AI_NFF_PARSE_FLOAT(s.diffuse.r);
+                AI_NFF_PARSE_FLOAT(s.specular.r);
+                AI_NFF_PARSE_FLOAT(d); // skip shininess and transmittance
+                AI_NFF_PARSE_FLOAT(d);
+                AI_NFF_PARSE_FLOAT(s.refracti);
+
+                // NFF2 uses full colors here so we need to use them too
+                // although NFF uses simple scaling factors
+                s.diffuse.g  = s.diffuse.b = s.diffuse.r;
+                s.specular.g = s.specular.b = s.specular.r;
+
+                // if the next one is NOT a number we assume it is a texture file name
+                // this feature is used by some NFF files on the internet and it has
+                // been implemented as it can be really useful
+                SkipSpaces(&sz);
+                if (!IsNumeric(*sz))
+                {
+                    // TODO: Support full file names with spaces and quotation marks ...
+                    const char* p = sz;
+                    while (!IsSpaceOrNewLine( *sz ))++sz;
+
+                    unsigned int diff = (unsigned int)(sz-p);
+                    if (diff)
+                    {
+                        s.texFile = std::string(p,diff);
+                    }
+                }
+                else
+                {
+                    AI_NFF_PARSE_FLOAT(s.ambient); // optional
+                }
+            }
+            // 'shader' - other way to specify a texture
+            else if (TokenMatch(sz,"shader",6))
+            {
+                SkipSpaces(&sz);
+                const char* old = sz;
+                while (!IsSpaceOrNewLine(*sz))++sz;
+                s.texFile = std::string(old, (uintptr_t)sz - (uintptr_t)old);
+            }
+            // 'l' - light source
+            else if (TokenMatch(sz,"l",1))
+            {
+                lights.push_back(Light());
+                Light& light = lights.back();
+
+                AI_NFF_PARSE_TRIPLE(light.position);
+                AI_NFF_PARSE_FLOAT (light.intensity);
+                AI_NFF_PARSE_TRIPLE(light.color);
+            }
+            // 's' - sphere
+            else if (TokenMatch(sz,"s",1))
+            {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
+                MeshInfo& currentMesh = meshesLocked.back();
+                currentMesh.shader = s;
+                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+
+                AI_NFF_PARSE_SHAPE_INFORMATION();
+
+                // we don't need scaling or translation here - we do it in the node's transform
+                StandardShapes::MakeSphere(iTesselation, currentMesh.vertices);
+                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+
+                // generate a name for the mesh
+                ::ai_snprintf(currentMesh.name,128,"sphere_%i",sphere++);
+            }
+            // 'dod' - dodecahedron
+            else if (TokenMatch(sz,"dod",3))
+            {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
+                MeshInfo& currentMesh = meshesLocked.back();
+                currentMesh.shader = s;
+                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+
+                AI_NFF_PARSE_SHAPE_INFORMATION();
+
+                // we don't need scaling or translation here - we do it in the node's transform
+                StandardShapes::MakeDodecahedron(currentMesh.vertices);
+                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+
+                // generate a name for the mesh
+                ::ai_snprintf(currentMesh.name,128,"dodecahedron_%i",dodecahedron++);
+            }
+
+            // 'oct' - octahedron
+            else if (TokenMatch(sz,"oct",3))
+            {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
+                MeshInfo& currentMesh = meshesLocked.back();
+                currentMesh.shader = s;
+                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+
+                AI_NFF_PARSE_SHAPE_INFORMATION();
+
+                // we don't need scaling or translation here - we do it in the node's transform
+                StandardShapes::MakeOctahedron(currentMesh.vertices);
+                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+
+                // generate a name for the mesh
+                ::ai_snprintf(currentMesh.name,128,"octahedron_%i",octahedron++);
+            }
+
+            // 'tet' - tetrahedron
+            else if (TokenMatch(sz,"tet",3))
+            {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
+                MeshInfo& currentMesh = meshesLocked.back();
+                currentMesh.shader = s;
+                currentMesh.shader.mapping = aiTextureMapping_SPHERE;
+
+                AI_NFF_PARSE_SHAPE_INFORMATION();
+
+                // we don't need scaling or translation here - we do it in the node's transform
+                StandardShapes::MakeTetrahedron(currentMesh.vertices);
+                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+
+                // generate a name for the mesh
+                ::ai_snprintf(currentMesh.name,128,"tetrahedron_%i",tetrahedron++);
+            }
+
+            // 'hex' - hexahedron
+            else if (TokenMatch(sz,"hex",3))
+            {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
+                MeshInfo& currentMesh = meshesLocked.back();
+                currentMesh.shader = s;
+                currentMesh.shader.mapping = aiTextureMapping_BOX;
+
+                AI_NFF_PARSE_SHAPE_INFORMATION();
+
+                // we don't need scaling or translation here - we do it in the node's transform
+                StandardShapes::MakeHexahedron(currentMesh.vertices);
+                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+
+                // generate a name for the mesh
+                ::ai_snprintf(currentMesh.name,128,"hexahedron_%i",hexahedron++);
+            }
+            // 'c' - cone
+            else if (TokenMatch(sz,"c",1))
+            {
+                meshesLocked.push_back(MeshInfo(PatchType_Simple,true));
+                MeshInfo& currentMesh = meshesLocked.back();
+                currentMesh.shader = s;
+                currentMesh.shader.mapping = aiTextureMapping_CYLINDER;
+
+                if(!GetNextLine(buffer,line))
+                {
+                    DefaultLogger::get()->error("NFF: Unexpected end of file (cone definition not complete)");
+                    break;
+                }
+                sz = line;
+
+                // read the two center points and the respective radii
+                aiVector3D center1, center2; float radius1, radius2;
+                AI_NFF_PARSE_TRIPLE(center1);
+                AI_NFF_PARSE_FLOAT(radius1);
+
+                if(!GetNextLine(buffer,line))
+                {
+                    DefaultLogger::get()->error("NFF: Unexpected end of file (cone definition not complete)");
+                    break;
+                }
+                sz = line;
+
+                AI_NFF_PARSE_TRIPLE(center2);
+                AI_NFF_PARSE_FLOAT(radius2);
+
+                // compute the center point of the cone/cylinder -
+                // it is its local transformation origin
+                currentMesh.dir    =  center2-center1;
+                currentMesh.center =  center1+currentMesh.dir/(ai_real)2.0;
+
+                float f;
+                if (( f = currentMesh.dir.Length()) < 10e-3f )
+                {
+                    DefaultLogger::get()->error("NFF: Cone height is close to zero");
+                    continue;
+                }
+                currentMesh.dir /= f; // normalize
+
+                // generate the cone - it consists of simple triangles
+                StandardShapes::MakeCone(f, radius1, radius2,
+                    integer_pow(4, iTesselation), currentMesh.vertices);
+
+                // MakeCone() returns tris
+                currentMesh.faces.resize(currentMesh.vertices.size()/3,3);
+
+                // generate a name for the mesh. 'cone' if it a cone,
+                // 'cylinder' if it is a cylinder. Funny, isn't it?
+                if (radius1 != radius2)
+                    ::ai_snprintf(currentMesh.name,128,"cone_%i",cone++);
+                else ::ai_snprintf(currentMesh.name,128,"cylinder_%i",cylinder++);
+            }
+            // 'tess' - tesselation
+            else if (TokenMatch(sz,"tess",4))
+            {
+                SkipSpaces(&sz);
+                iTesselation = strtoul10(sz);
+            }
+            // 'from' - camera position
+            else if (TokenMatch(sz,"from",4))
+            {
+                AI_NFF_PARSE_TRIPLE(camPos);
+                hasCam = true;
+            }
+            // 'at' - camera look-at vector
+            else if (TokenMatch(sz,"at",2))
+            {
+                AI_NFF_PARSE_TRIPLE(camLookAt);
+                hasCam = true;
+            }
+            // 'up' - camera up vector
+            else if (TokenMatch(sz,"up",2))
+            {
+                AI_NFF_PARSE_TRIPLE(camUp);
+                hasCam = true;
+            }
+            // 'angle' - (half?) camera field of view
+            else if (TokenMatch(sz,"angle",5))
+            {
+                AI_NFF_PARSE_FLOAT(angle);
+                hasCam = true;
+            }
+            // 'resolution' - used to compute the screen aspect
+            else if (TokenMatch(sz,"resolution",10))
+            {
+                AI_NFF_PARSE_FLOAT(resolution.x);
+                AI_NFF_PARSE_FLOAT(resolution.y);
+                hasCam = true;
+            }
+            // 'pb' - bezier patch. Not supported yet
+            else if (TokenMatch(sz,"pb",2))
+            {
+                DefaultLogger::get()->error("NFF: Encountered unsupported ID: bezier patch");
+            }
+            // 'pn' - NURBS. Not supported yet
+            else if (TokenMatch(sz,"pn",2) || TokenMatch(sz,"pnn",3))
+            {
+                DefaultLogger::get()->error("NFF: Encountered unsupported ID: NURBS");
+            }
+            // '' - comment
+            else if ('#' == line[0])
+            {
+                const char* sz;SkipSpaces(&line[1],&sz);
+                if (!IsLineEnd(*sz))DefaultLogger::get()->info(sz);
+            }
+        }
+    }
+
+    // copy all arrays into one large
+    meshes.reserve (meshes.size()+meshesLocked.size()+meshesWithNormals.size()+meshesWithUVCoords.size());
+    meshes.insert  (meshes.end(),meshesLocked.begin(),meshesLocked.end());
+    meshes.insert  (meshes.end(),meshesWithNormals.begin(),meshesWithNormals.end());
+    meshes.insert  (meshes.end(),meshesWithUVCoords.begin(),meshesWithUVCoords.end());
+
+    // now generate output meshes. first find out how many meshes we'll need
+    std::vector<MeshInfo>::const_iterator it = meshes.begin(), end = meshes.end();
+    for (;it != end;++it)
+    {
+        if (!(*it).faces.empty())
+        {
+            ++pScene->mNumMeshes;
+            if ((*it).name[0])++numNamed;
+        }
+    }
+
+    // generate a dummy root node - assign all unnamed elements such
+    // as polygons and polygon patches to the root node and generate
+    // sub nodes for named objects such as spheres and cones.
+    aiNode* const root = new aiNode();
+    root->mName.Set("<NFF_Root>");
+    root->mNumChildren = numNamed + (hasCam ? 1 : 0) + (unsigned int) lights.size();
+    root->mNumMeshes = pScene->mNumMeshes-numNamed;
+
+    aiNode** ppcChildren = NULL;
+    unsigned int* pMeshes = NULL;
+    if (root->mNumMeshes)
+        pMeshes = root->mMeshes = new unsigned int[root->mNumMeshes];
+    if (root->mNumChildren)
+        ppcChildren = root->mChildren = new aiNode*[root->mNumChildren];
+
+    // generate the camera
+    if (hasCam)
+    {
+        ai_assert(ppcChildren);
+        aiNode* nd = new aiNode();
+        *ppcChildren = nd;
+        nd->mName.Set("<NFF_Camera>");
+        nd->mParent = root;
+
+        // allocate the camera in the scene
+        pScene->mNumCameras = 1;
+        pScene->mCameras = new aiCamera*[1];
+        aiCamera* c = pScene->mCameras[0] = new aiCamera;
+
+        c->mName = nd->mName; // make sure the names are identical
+        c->mHorizontalFOV = AI_DEG_TO_RAD( angle );
+        c->mLookAt      = camLookAt - camPos;
+        c->mPosition    = camPos;
+        c->mUp          = camUp;
+
+        // If the resolution is not specified in the file, we
+        // need to set 1.0 as aspect.
+        c->mAspect      = (!resolution.y ? 0.f : resolution.x / resolution.y);
+        ++ppcChildren;
+    }
+
+    // generate light sources
+    if (!lights.empty())
+    {
+        ai_assert(ppcChildren);
+        pScene->mNumLights = (unsigned int)lights.size();
+        pScene->mLights = new aiLight*[pScene->mNumLights];
+        for (unsigned int i = 0; i < pScene->mNumLights;++i,++ppcChildren)
+        {
+            const Light& l = lights[i];
+
+            aiNode* nd = new aiNode();
+            *ppcChildren = nd;
+            nd->mParent = root;
+
+            nd->mName.length = ::ai_snprintf(nd->mName.data,1024,"<NFF_Light%u>",i);
+
+            // allocate the light in the scene data structure
+            aiLight* out = pScene->mLights[i] = new aiLight();
+            out->mName = nd->mName; // make sure the names are identical
+            out->mType = aiLightSource_POINT;
+            out->mColorDiffuse = out->mColorSpecular = l.color * l.intensity;
+            out->mPosition = l.position;
+        }
+    }
+
+    if (!pScene->mNumMeshes)throw DeadlyImportError("NFF: No meshes loaded");
+    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
+    pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials = pScene->mNumMeshes];
+    unsigned int m = 0;
+    for (it = meshes.begin(); it != end;++it)
+    {
+        if ((*it).faces.empty())continue;
+
+        const MeshInfo& src = *it;
+        aiMesh* const mesh = pScene->mMeshes[m] = new aiMesh();
+        mesh->mNumVertices = (unsigned int)src.vertices.size();
+        mesh->mNumFaces = (unsigned int)src.faces.size();
+
+        // Generate sub nodes for named meshes
+        if ( src.name[ 0 ] && NULL != ppcChildren  ) {
+            aiNode* const node = *ppcChildren = new aiNode();
+            node->mParent = root;
+            node->mNumMeshes = 1;
+            node->mMeshes = new unsigned int[1];
+            node->mMeshes[0] = m;
+            node->mName.Set(src.name);
+
+            // setup the transformation matrix of the node
+            aiMatrix4x4::FromToMatrix(aiVector3D(0.f,1.f,0.f),
+                src.dir,node->mTransformation);
+
+            aiMatrix4x4& mat = node->mTransformation;
+            mat.a1 *= src.radius.x; mat.b1 *= src.radius.x; mat.c1 *= src.radius.x;
+            mat.a2 *= src.radius.y; mat.b2 *= src.radius.y; mat.c2 *= src.radius.y;
+            mat.a3 *= src.radius.z; mat.b3 *= src.radius.z; mat.c3 *= src.radius.z;
+            mat.a4 = src.center.x;
+            mat.b4 = src.center.y;
+            mat.c4 = src.center.z;
+
+            ++ppcChildren;
+        } else {
+            *pMeshes++ = m;
+        }
+
+        // copy vertex positions
+        mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+        ::memcpy(mesh->mVertices,&src.vertices[0],
+            sizeof(aiVector3D)*mesh->mNumVertices);
+
+        // NFF2: there could be vertex colors
+        if (!src.colors.empty())
+        {
+            ai_assert(src.colors.size() == src.vertices.size());
+
+            // copy vertex colors
+            mesh->mColors[0] = new aiColor4D[mesh->mNumVertices];
+            ::memcpy(mesh->mColors[0],&src.colors[0],
+                sizeof(aiColor4D)*mesh->mNumVertices);
+        }
+
+        if (!src.normals.empty())
+        {
+            ai_assert(src.normals.size() == src.vertices.size());
+
+            // copy normal vectors
+            mesh->mNormals = new aiVector3D[mesh->mNumVertices];
+            ::memcpy(mesh->mNormals,&src.normals[0],
+                sizeof(aiVector3D)*mesh->mNumVertices);
+        }
+
+        if (!src.uvs.empty())
+        {
+            ai_assert(src.uvs.size() == src.vertices.size());
+
+            // copy texture coordinates
+            mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
+            ::memcpy(mesh->mTextureCoords[0],&src.uvs[0],
+                sizeof(aiVector3D)*mesh->mNumVertices);
+        }
+
+        // generate faces
+        unsigned int p = 0;
+        aiFace* pFace = mesh->mFaces = new aiFace[mesh->mNumFaces];
+        for (std::vector<unsigned int>::const_iterator it2 = src.faces.begin(),
+            end2 = src.faces.end();
+            it2 != end2;++it2,++pFace)
+        {
+            pFace->mIndices = new unsigned int [ pFace->mNumIndices = *it2 ];
+            for (unsigned int o = 0; o < pFace->mNumIndices;++o)
+                pFace->mIndices[o] = p++;
+        }
+
+        // generate a material for the mesh
+        aiMaterial* pcMat = (aiMaterial*)(pScene->mMaterials[m] = new aiMaterial());
+
+        mesh->mMaterialIndex = m++;
+
+        aiString s;
+        s.Set(AI_DEFAULT_MATERIAL_NAME);
+        pcMat->AddProperty(&s, AI_MATKEY_NAME);
+
+        // FIX: Ignore diffuse == 0
+        aiColor3D c = src.shader.color * (src.shader.diffuse.r ?  src.shader.diffuse : aiColor3D(1.f,1.f,1.f));
+        pcMat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);
+        c = src.shader.color * src.shader.specular;
+        pcMat->AddProperty(&c,1,AI_MATKEY_COLOR_SPECULAR);
+
+        // NFF2 - default values for NFF
+        pcMat->AddProperty(&src.shader.ambient, 1,AI_MATKEY_COLOR_AMBIENT);
+        pcMat->AddProperty(&src.shader.emissive,1,AI_MATKEY_COLOR_EMISSIVE);
+        pcMat->AddProperty(&src.shader.opacity, 1,AI_MATKEY_OPACITY);
+
+        // setup the first texture layer, if existing
+        if (src.shader.texFile.length())
+        {
+            s.Set(src.shader.texFile);
+            pcMat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(0));
+
+            if (aiTextureMapping_UV != src.shader.mapping) {
+
+                aiVector3D v(0.f,-1.f,0.f);
+                pcMat->AddProperty(&v, 1,AI_MATKEY_TEXMAP_AXIS_DIFFUSE(0));
+                pcMat->AddProperty((int*)&src.shader.mapping, 1,AI_MATKEY_MAPPING_DIFFUSE(0));
+            }
+        }
+
+        // setup the name of the material
+        if (src.shader.name.length())
+        {
+            s.Set(src.shader.texFile);
+            pcMat->AddProperty(&s,AI_MATKEY_NAME);
+        }
+
+        // setup some more material properties that are specific to NFF2
+        int i;
+        if (src.shader.twoSided)
+        {
+            i = 1;
+            pcMat->AddProperty(&i,1,AI_MATKEY_TWOSIDED);
+        }
+        i = (src.shader.shaded ? aiShadingMode_Gouraud : aiShadingMode_NoShading);
+        if (src.shader.shininess)
+        {
+            i = aiShadingMode_Phong;
+            pcMat->AddProperty(&src.shader.shininess,1,AI_MATKEY_SHININESS);
+        }
+        pcMat->AddProperty(&i,1,AI_MATKEY_SHADING_MODEL);
+    }
+    pScene->mRootNode = root;
+}
+
+#endif // !! ASSIMP_BUILD_NO_NFF_IMPORTER