| /* |
| --------------------------------------------------------------------------- |
| 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 |
