/* --------------------------------------------------------------------------- Open Asset Import Library (assimp) --------------------------------------------------------------------------- Copyright (c) 2006-2022, assimp team All rights reserved. Redistribution and use of this software in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the assimp team, nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission of the assimp team. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. --------------------------------------------------------------------------- */ /** @file Implementation of the IrrMesh importer class */ #ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER #include "IRRMeshLoader.h" #include #include #include #include #include #include #include #include #include using namespace Assimp; static constexpr aiImporterDesc desc = { "Irrlicht Mesh Reader", "", "", "http://irrlicht.sourceforge.net/", aiImporterFlags_SupportTextFlavour, 0, 0, 0, 0, "xml irrmesh" }; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer IRRMeshImporter::IRRMeshImporter() = default; // ------------------------------------------------------------------------------------------------ // Destructor, private as well IRRMeshImporter::~IRRMeshImporter() = default; // ------------------------------------------------------------------------------------------------ // Returns whether the class can handle the format of the given file. bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { /* NOTE: A simple check for the file extension is not enough * here. Irrmesh and irr are easy, but xml is too generic * and could be collada, too. So we need to open the file and * search for typical tokens. */ static const char *tokens[] = { "irrmesh" }; return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); } // ------------------------------------------------------------------------------------------------ // Get a list of all file extensions which are handled by this class const aiImporterDesc *IRRMeshImporter::GetInfo() const { return &desc; } static void releaseMaterial(aiMaterial **mat) { if (*mat != nullptr) { delete *mat; *mat = nullptr; } } static void releaseMesh(aiMesh **mesh) { if (*mesh != nullptr) { delete *mesh; *mesh = nullptr; } } // ------------------------------------------------------------------------------------------------ // Imports the given file into the given scene structure. void IRRMeshImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { std::unique_ptr file(pIOHandler->Open(pFile)); // Check whether we can read from the file if (file == nullptr) throw DeadlyImportError("Failed to open IRRMESH file ", pFile); // Construct the irrXML parser XmlParser parser; if (!parser.parse(file.get())) { throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile); } XmlNode root = parser.getRootNode(); // final data std::vector materials; std::vector meshes; materials.reserve(5); meshes.reserve(5); // temporary data - current mesh buffer // TODO move all these to inside loop aiMaterial *curMat = nullptr; aiMesh *curMesh = nullptr; unsigned int curMatFlags = 0; std::vector curVertices, curNormals, curTangents, curBitangents; std::vector curColors; std::vector curUVs, curUV2s; // some temporary variables // textMeaning is a 15 year old variable, that could've been an enum // int textMeaning = 0; // 0=none? 1=vertices 2=indices // int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents bool useColors = false; /* ** irrmesh files have a top level owning multiple nodes. ** Each contains , , and ** tags here directly owns the material data specs ** are a vertex per line, contains position, UV1 coords, maybe UV2, normal, tangent, bitangent ** is ignored, I think assimp recalculates those? */ // Parse the XML file pugi::xml_node const &meshNode = root.child("mesh"); for (pugi::xml_node bufferNode : meshNode.children()) { if (ASSIMP_stricmp(bufferNode.name(), "buffer")) { // Might be a useless warning ASSIMP_LOG_WARN("IRRMESH: Ignoring non buffer node <", bufferNode.name(), "> in mesh declaration"); continue; } curMat = nullptr; curMesh = nullptr; curVertices.clear(); curColors.clear(); curNormals.clear(); curUV2s.clear(); curUVs.clear(); curTangents.clear(); curBitangents.clear(); // TODO ensure all three nodes are present and populated // before allocating everything // Get first material node pugi::xml_node materialNode = bufferNode.child("material"); if (materialNode) { curMat = ParseMaterial(materialNode, curMatFlags); // Warn if there's more materials if (materialNode.next_sibling("material")) { ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please"); } } else { ASSIMP_LOG_ERROR("IRRMESH: Buffer must contain one material"); continue; } // Get first vertices node pugi::xml_node verticesNode = bufferNode.child("vertices"); if (verticesNode) { pugi::xml_attribute vertexCountAttrib = verticesNode.attribute("vertexCount"); int vertexCount = vertexCountAttrib.as_int(); if (vertexCount == 0) { // This is possible ... remove the mesh from the list and skip further reading ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices"); releaseMaterial(&curMat); // releaseMesh(&curMesh); continue; // Bail out early }; curVertices.reserve(vertexCount); curNormals.reserve(vertexCount); curColors.reserve(vertexCount); curUVs.reserve(vertexCount); VertexFormat vertexFormat; // Determine the file format pugi::xml_attribute typeAttrib = verticesNode.attribute("type"); if (!ASSIMP_stricmp("2tcoords", typeAttrib.value())) { curUV2s.reserve(vertexCount); vertexFormat = VertexFormat::t2coord; if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) { // ********************************************************* // We have a second texture! So use this UV channel // for it. The 2nd texture can be either a normal // texture (solid_2layer or lightmap_xxx) or a normal // map (normal_..., parallax_...) // ********************************************************* int idx = 1; aiMaterial *mat = (aiMaterial *)curMat; if (curMatFlags & AI_IRRMESH_MAT_lightmap) { mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0)); } else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) { mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0)); } else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) { mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1)); } } } else if (!ASSIMP_stricmp("tangents", typeAttrib.value())) { curTangents.reserve(vertexCount); curBitangents.reserve(vertexCount); vertexFormat = VertexFormat::tangent; } else if (!ASSIMP_stricmp("standard", typeAttrib.value())) { vertexFormat = VertexFormat::standard; } else { // Unsupported format, discard whole buffer/mesh // Assuming we have a correct material, then release it // We don't have a correct mesh for sure here releaseMaterial(&curMat); ASSIMP_LOG_ERROR("IRRMESH: Unknown vertex format"); continue; // Skip rest of buffer }; // We know what format buffer is, collect numbers std::string v = verticesNode.text().get(); const char *end = v.c_str() + v.size(); ParseBufferVertices(v.c_str(), end, vertexFormat, curVertices, curNormals, curTangents, curBitangents, curUVs, curUV2s, curColors, useColors); } // Get indices // At this point we have some vertices and a valid material // Collect indices and create aiMesh at the same time pugi::xml_node indicesNode = bufferNode.child("indices"); if (indicesNode) { // start a new mesh curMesh = new aiMesh(); // allocate storage for all faces pugi::xml_attribute attr = indicesNode.attribute("indexCount"); curMesh->mNumVertices = attr.as_int(); if (!curMesh->mNumVertices) { // This is possible ... remove the mesh from the list and skip further reading ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices"); // mesh - away releaseMesh(&curMesh); // material - away releaseMaterial(&curMat); continue; // Go to next buffer } if (curMesh->mNumVertices % 3) { ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3"); } curMesh->mNumFaces = curMesh->mNumVertices / 3; curMesh->mFaces = new aiFace[curMesh->mNumFaces]; // setup some members curMesh->mMaterialIndex = (unsigned int)materials.size(); curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; // allocate storage for all vertices curMesh->mVertices = new aiVector3D[curMesh->mNumVertices]; if (curNormals.size() == curVertices.size()) { curMesh->mNormals = new aiVector3D[curMesh->mNumVertices]; } if (curTangents.size() == curVertices.size()) { curMesh->mTangents = new aiVector3D[curMesh->mNumVertices]; } if (curBitangents.size() == curVertices.size()) { curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices]; } if (curColors.size() == curVertices.size() && useColors) { curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices]; } if (curUVs.size() == curVertices.size()) { curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices]; } if (curUV2s.size() == curVertices.size()) { curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices]; } // read indices aiFace *curFace = curMesh->mFaces; aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces; aiVector3D *pcV = curMesh->mVertices; aiVector3D *pcN = curMesh->mNormals; aiVector3D *pcT = curMesh->mTangents; aiVector3D *pcB = curMesh->mBitangents; aiColor4D *pcC0 = curMesh->mColors[0]; aiVector3D *pcT0 = curMesh->mTextureCoords[0]; aiVector3D *pcT1 = curMesh->mTextureCoords[1]; unsigned int curIdx = 0; unsigned int total = 0; // NOTE this might explode for UTF-16 and wchars const char *sz = indicesNode.text().get(); const char *end = sz + std::strlen(sz) + 1; // For each index loop over aiMesh faces while (SkipSpacesAndLineEnd(&sz, end)) { if (curFace >= faceEnd) { ASSIMP_LOG_ERROR("IRRMESH: Too many indices"); break; } // if new face if (!curIdx) { curFace->mNumIndices = 3; curFace->mIndices = new unsigned int[3]; } // Read index base 10 // function advances the pointer unsigned int idx = strtoul10(sz, &sz); if (idx >= curVertices.size()) { ASSIMP_LOG_ERROR("IRRMESH: Index out of range"); idx = 0; } // make up our own indices? curFace->mIndices[curIdx] = total++; // Copy over data to aiMesh *pcV++ = curVertices[idx]; if (pcN) *pcN++ = curNormals[idx]; if (pcT) *pcT++ = curTangents[idx]; if (pcB) *pcB++ = curBitangents[idx]; if (pcC0) *pcC0++ = curColors[idx]; if (pcT0) *pcT0++ = curUVs[idx]; if (pcT1) *pcT1++ = curUV2s[idx]; // start new face if (++curIdx == 3) { ++curFace; curIdx = 0; } } // We should be at the end of mFaces if (curFace != faceEnd) ASSIMP_LOG_ERROR("IRRMESH: Not enough indices"); } // Finish processing the mesh - do some small material workarounds if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) { // Take the opacity value of the current material // from the common vertex color alpha aiMaterial *mat = (aiMaterial *)curMat; mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY); } // textMeaning = 2; // end of previous buffer. A material and a mesh should be there if (!curMat || !curMesh) { ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material"); releaseMaterial(&curMat); releaseMesh(&curMesh); } else { materials.push_back(curMat); meshes.push_back(curMesh); } } // If one is empty then so is the other if (materials.empty() || meshes.empty()) { throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file"); } // now generate the output scene pScene->mNumMeshes = (unsigned int)meshes.size(); pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]; for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { pScene->mMeshes[i] = meshes[i]; // clean this value ... pScene->mMeshes[i]->mNumUVComponents[3] = 0; } pScene->mNumMaterials = (unsigned int)materials.size(); pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials]; ::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials); pScene->mRootNode = new aiNode(); pScene->mRootNode->mName.Set(""); pScene->mRootNode->mNumMeshes = pScene->mNumMeshes; pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes]; for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) { pScene->mRootNode->mMeshes[i] = i; }; } void IRRMeshImporter::ParseBufferVertices(const char *sz, const char *end, VertexFormat vertexFormat, std::vector &vertices, std::vector &normals, std::vector &tangents, std::vector &bitangents, std::vector &UVs, std::vector &UV2s, std::vector &colors, bool &useColors) { // read vertices do { SkipSpacesAndLineEnd(&sz, end); aiVector3D temp; aiColor4D c; // Read the vertex position sz = fast_atoreal_move(sz, (float &)temp.x); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.y); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.z); SkipSpaces(&sz, end); vertices.push_back(temp); // Read the vertex normals sz = fast_atoreal_move(sz, (float &)temp.x); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.y); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.z); SkipSpaces(&sz, end); normals.push_back(temp); // read the vertex colors uint32_t clr = strtoul16(sz, &sz); ColorFromARGBPacked(clr, c); // If we're pushing more than one distinct color if (!colors.empty() && c != *(colors.end() - 1)) useColors = true; colors.push_back(c); SkipSpaces(&sz, end); // read the first UV coordinate set sz = fast_atoreal_move(sz, (float &)temp.x); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.y); SkipSpaces(&sz, end); temp.z = 0.f; temp.y = 1.f - temp.y; // DX to OGL UVs.push_back(temp); // NOTE these correspond to specific S3DVertex* structs in irr sourcecode // So by definition, all buffers have either UV2 or tangents or neither // read the (optional) second UV coordinate set if (vertexFormat == VertexFormat::t2coord) { sz = fast_atoreal_move(sz, (float &)temp.x); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.y); temp.y = 1.f - temp.y; // DX to OGL UV2s.push_back(temp); } // read optional tangent and bitangent vectors else if (vertexFormat == VertexFormat::tangent) { // tangents sz = fast_atoreal_move(sz, (float &)temp.x); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.z); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.y); SkipSpaces(&sz, end); temp.y *= -1.0f; tangents.push_back(temp); // bitangents sz = fast_atoreal_move(sz, (float &)temp.x); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.z); SkipSpaces(&sz, end); sz = fast_atoreal_move(sz, (float &)temp.y); SkipSpaces(&sz, end); temp.y *= -1.0f; bitangents.push_back(temp); } } while (SkipLine(&sz, end)); // IMPORTANT: We assume that each vertex is specified in one // line. So we can skip the rest of the line - unknown vertex // elements are ignored. } #endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER