/* --------------------------------------------------------------------------- Open Asset Import Library (assimp) --------------------------------------------------------------------------- Copyright (c) 2006-2018, 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 #include #include #include #include #include #include #include #include #include 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(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& output, const std::string& path, IOSystem* pIOHandler) { std::unique_ptr 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 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 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 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 meshes; std::vector meshesWithNormals; std::vector meshesWithUVCoords; std::vector 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 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 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 tempColors; std::vector 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 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::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::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::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(""); 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(""); 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,"",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::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