diff options
Diffstat (limited to 'libs/assimp/code/AssetLib/XGL')
| -rw-r--r-- | libs/assimp/code/AssetLib/XGL/XGLLoader.cpp | 787 | ||||
| -rw-r--r-- | libs/assimp/code/AssetLib/XGL/XGLLoader.h | 209 |
2 files changed, 996 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/XGL/XGLLoader.cpp b/libs/assimp/code/AssetLib/XGL/XGLLoader.cpp new file mode 100644 index 0000000..154af98 --- /dev/null +++ b/libs/assimp/code/AssetLib/XGL/XGLLoader.cpp @@ -0,0 +1,787 @@ +/* +--------------------------------------------------------------------------- +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 XGL/ZGL importer class */ + +#ifndef ASSIMP_BUILD_NO_XGL_IMPORTER + +#include "XGLLoader.h" +#include "Common/Compression.h" + +#include <assimp/ParsingUtils.h> +#include <assimp/fast_atof.h> +#include <assimp/MemoryIOWrapper.h> +#include <assimp/StreamReader.h> +#include <assimp/importerdesc.h> +#include <assimp/mesh.h> +#include <assimp/scene.h> +//#include <cctype> +//#include <memory> + +using namespace Assimp; + +namespace Assimp { // this has to be in here because LogFunctions is in ::Assimp + +template <> +const char *LogFunctions<XGLImporter>::Prefix() { + static auto prefix = "XGL: "; + return prefix; +} + +} // namespace Assimp + +static const aiImporterDesc desc = { + "XGL Importer", + "", + "", + "", + aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour, + 0, + 0, + 0, + 0, + "xgl zgl" +}; + +// ------------------------------------------------------------------------------------------------ +// Constructor to be privately used by Importer +XGLImporter::XGLImporter() : + mXmlParser(nullptr), + m_scene(nullptr) { + // empty +} + +// ------------------------------------------------------------------------------------------------ +// Destructor, private as well +XGLImporter::~XGLImporter() { + delete mXmlParser; +} + +// ------------------------------------------------------------------------------------------------ +// Returns whether the class can handle the format of the given file. +bool XGLImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { + static const char *tokens[] = { "<world>", "<World>", "<WORLD>" }; + return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens)); +} + +// ------------------------------------------------------------------------------------------------ +// Get a list of all file extensions which are handled by this class +const aiImporterDesc *XGLImporter::GetInfo() const { + return &desc; +} + +// ------------------------------------------------------------------------------------------------ +// Imports the given file into the given scene structure. +void XGLImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { + #ifndef ASSIMP_BUILD_NO_COMPRESSED_XGL + std::vector<char> uncompressed; +#endif + + m_scene = pScene; + std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile, "rb")); + + // check whether we can read from the file + if (stream.get() == NULL) { + throw DeadlyImportError("Failed to open XGL/ZGL file " + pFile); + } + + // see if its compressed, if so uncompress it + if (GetExtension(pFile) == "zgl") { +#ifdef ASSIMP_BUILD_NO_COMPRESSED_XGL + ThrowException("Cannot read ZGL file since Assimp was built without compression support"); +#else + std::unique_ptr<StreamReaderLE> raw_reader(new StreamReaderLE(stream)); + + Compression compression; + size_t total = 0l; + if (compression.open(Compression::Format::Binary, Compression::FlushMode::NoFlush, -Compression::MaxWBits)) { + // skip two extra bytes, zgl files do carry a crc16 upfront (I think) + raw_reader->IncPtr(2); + total = compression.decompress((unsigned char *)raw_reader->GetPtr(), raw_reader->GetRemainingSize(), uncompressed); + compression.close(); + } + // replace the input stream with a memory stream + stream.reset(new MemoryIOStream(reinterpret_cast<uint8_t*>(uncompressed.data()), total)); +#endif + } + + // parse the XML file + mXmlParser = new XmlParser; + if (!mXmlParser->parse(stream.get())) { + throw DeadlyImportError("XML parse error while loading XGL file ", pFile); + } + + TempScope scope; + XmlNode *worldNode = mXmlParser->findNode("WORLD"); + if (nullptr != worldNode) { + ReadWorld(*worldNode, scope); + } + + std::vector<aiMesh *> &meshes = scope.meshes_linear; + std::vector<aiMaterial *> &materials = scope.materials_linear; + if (!meshes.size() || !materials.size()) { + ThrowException("failed to extract data from XGL file, no meshes loaded"); + } + + // copy meshes + m_scene->mNumMeshes = static_cast<unsigned int>(meshes.size()); + m_scene->mMeshes = new aiMesh *[m_scene->mNumMeshes](); + std::copy(meshes.begin(), meshes.end(), m_scene->mMeshes); + + // copy materials + m_scene->mNumMaterials = static_cast<unsigned int>(materials.size()); + m_scene->mMaterials = new aiMaterial *[m_scene->mNumMaterials](); + std::copy(materials.begin(), materials.end(), m_scene->mMaterials); + + if (scope.light) { + m_scene->mNumLights = 1; + m_scene->mLights = new aiLight *[1]; + m_scene->mLights[0] = scope.light; + + scope.light->mName = m_scene->mRootNode->mName; + } + + scope.dismiss(); +} + +// ------------------------------------------------------------------------------------------------ +void XGLImporter::ReadWorld(XmlNode &node, TempScope &scope) { + for (XmlNode ¤tNode : node.children()) { + const std::string &s = ai_stdStrToLower(currentNode.name()); + + // XXX right now we'd skip <lighting> if it comes after + // <object> or <mesh> + if (s == "lighting") { + ReadLighting(currentNode, scope); + } else if (s == "object" || s == "mesh" || s == "mat") { + break; + } + } + + aiNode *const nd = ReadObject(node, scope); + if (!nd) { + ThrowException("failure reading <world>"); + } + if (nd->mName.length == 0) { + nd->mName.Set("WORLD"); + } + + m_scene->mRootNode = nd; +} + +// ------------------------------------------------------------------------------------------------ +void XGLImporter::ReadLighting(XmlNode &node, TempScope &scope) { + const std::string &s = ai_stdStrToLower(node.name()); + if (s == "directionallight") { + scope.light = ReadDirectionalLight(node); + } else if (s == "ambient") { + LogWarn("ignoring <ambient> tag"); + } else if (s == "spheremap") { + LogWarn("ignoring <spheremap> tag"); + } +} + +// ------------------------------------------------------------------------------------------------ +aiLight *XGLImporter::ReadDirectionalLight(XmlNode &node) { + std::unique_ptr<aiLight> l(new aiLight()); + l->mType = aiLightSource_DIRECTIONAL; + find_node_by_name_predicate predicate("directionallight"); + XmlNode child = node.find_child(predicate); + if (child.empty()) { + return nullptr; + } + + const std::string &s = ai_stdStrToLower(child.name()); + if (s == "direction") { + l->mDirection = ReadVec3(child); + } else if (s == "diffuse") { + l->mColorDiffuse = ReadCol3(child); + } else if (s == "specular") { + l->mColorSpecular = ReadCol3(child); + } + + return l.release(); +} + +// ------------------------------------------------------------------------------------------------ +aiNode *XGLImporter::ReadObject(XmlNode &node, TempScope &scope) { + aiNode *nd = new aiNode; + std::vector<aiNode *> children; + std::vector<unsigned int> meshes; + + try { + for (XmlNode &child : node.children()) { + const std::string &s = ai_stdStrToLower(child.name()); + if (s == "mesh") { + const size_t prev = scope.meshes_linear.size(); + bool empty; + if (ReadMesh(child, scope, empty)) { + const size_t newc = scope.meshes_linear.size(); + for (size_t i = 0; i < newc - prev; ++i) { + meshes.push_back(static_cast<unsigned int>(i + prev)); + } + } + } else if (s == "mat") { + ReadMaterial(child, scope); + } else if (s == "object") { + children.push_back(ReadObject(child, scope)); + } else if (s == "objectref") { + // XXX + } else if (s == "meshref") { + const unsigned int id = static_cast<unsigned int>(ReadIndexFromText(child)); + + std::multimap<unsigned int, aiMesh *>::iterator it = scope.meshes.find(id), end = scope.meshes.end(); + if (it == end) { + ThrowException("<meshref> index out of range"); + } + + for (; it != end && (*it).first == id; ++it) { + // ok, this is n^2 and should get optimized one day + aiMesh *const m = it->second; + unsigned int i = 0, mcount = static_cast<unsigned int>(scope.meshes_linear.size()); + for (; i < mcount; ++i) { + if (scope.meshes_linear[i] == m) { + meshes.push_back(i); + break; + } + } + + ai_assert(i < mcount); + } + } else if (s == "transform") { + nd->mTransformation = ReadTrafo(child); + } + } + } catch (...) { + for (aiNode *ch : children) { + delete ch; + } + throw; + } + + // FIX: since we used std::multimap<> to keep meshes by id, mesh order now depends on the behaviour + // of the multimap implementation with respect to the ordering of entries with same values. + // C++11 gives the guarantee that it uses insertion order, before it is implementation-specific. + // Sort by material id to always guarantee a deterministic result. + std::sort(meshes.begin(), meshes.end(), SortMeshByMaterialId(scope)); + + // link meshes to node + nd->mNumMeshes = static_cast<unsigned int>(meshes.size()); + if (0 != nd->mNumMeshes) { + nd->mMeshes = new unsigned int[nd->mNumMeshes](); + for (unsigned int i = 0; i < nd->mNumMeshes; ++i) { + nd->mMeshes[i] = meshes[i]; + } + } + + // link children to parent + nd->mNumChildren = static_cast<unsigned int>(children.size()); + if (nd->mNumChildren) { + nd->mChildren = new aiNode *[nd->mNumChildren](); + for (unsigned int i = 0; i < nd->mNumChildren; ++i) { + nd->mChildren[i] = children[i]; + children[i]->mParent = nd; + } + } + + return nd; +} + +// ------------------------------------------------------------------------------------------------ +aiMatrix4x4 XGLImporter::ReadTrafo(XmlNode &node) { + aiVector3D forward, up, right, position; + float scale = 1.0f; + + aiMatrix4x4 m; + XmlNode child = node.child("TRANSFORM"); + if (child.empty()) { + return m; + } + + for (XmlNode &sub_child : child.children()) { + const std::string &s = ai_stdStrToLower(sub_child.name()); + if (s == "forward") { + forward = ReadVec3(sub_child); + } else if (s == "up") { + up = ReadVec3(sub_child); + } else if (s == "position") { + position = ReadVec3(sub_child); + } + if (s == "scale") { + scale = ReadFloat(sub_child); + if (scale < 0.f) { + // this is wrong, but we can leave the value and pass it to the caller + LogError("found negative scaling in <transform>, ignoring"); + } + } + } + + if (forward.SquareLength() < 1e-4 || up.SquareLength() < 1e-4) { + LogError("A direction vector in <transform> is zero, ignoring trafo"); + return m; + } + + forward.Normalize(); + up.Normalize(); + + right = forward ^ up; + if (std::fabs(up * forward) > 1e-4) { + // this is definitely wrong - a degenerate coordinate space ruins everything + // so substitute identity transform. + LogError("<forward> and <up> vectors in <transform> are skewing, ignoring trafo"); + return m; + } + + right *= scale; + up *= scale; + forward *= scale; + + m.a1 = right.x; + m.b1 = right.y; + m.c1 = right.z; + + m.a2 = up.x; + m.b2 = up.y; + m.c2 = up.z; + + m.a3 = forward.x; + m.b3 = forward.y; + m.c3 = forward.z; + + m.a4 = position.x; + m.b4 = position.y; + m.c4 = position.z; + + return m; +} + +// ------------------------------------------------------------------------------------------------ +aiMesh *XGLImporter::ToOutputMesh(const TempMaterialMesh &m) { + std::unique_ptr<aiMesh> mesh(new aiMesh()); + + mesh->mNumVertices = static_cast<unsigned int>(m.positions.size()); + mesh->mVertices = new aiVector3D[mesh->mNumVertices]; + std::copy(m.positions.begin(), m.positions.end(), mesh->mVertices); + + if (!m.normals.empty()) { + mesh->mNormals = new aiVector3D[mesh->mNumVertices]; + std::copy(m.normals.begin(), m.normals.end(), mesh->mNormals); + } + + if (!m.uvs.empty()) { + mesh->mNumUVComponents[0] = 2; + mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices]; + + for (unsigned int i = 0; i < mesh->mNumVertices; ++i) { + mesh->mTextureCoords[0][i] = aiVector3D(m.uvs[i].x, m.uvs[i].y, 0.f); + } + } + + mesh->mNumFaces = static_cast<unsigned int>(m.vcounts.size()); + mesh->mFaces = new aiFace[m.vcounts.size()]; + + unsigned int idx = 0; + for (unsigned int i = 0; i < mesh->mNumFaces; ++i) { + aiFace &f = mesh->mFaces[i]; + f.mNumIndices = m.vcounts[i]; + f.mIndices = new unsigned int[f.mNumIndices]; + for (unsigned int c = 0; c < f.mNumIndices; ++c) { + f.mIndices[c] = idx++; + } + } + + ai_assert(idx == mesh->mNumVertices); + + mesh->mPrimitiveTypes = m.pflags; + mesh->mMaterialIndex = m.matid; + + return mesh.release(); +} + +// ------------------------------------------------------------------------------------------------ +bool XGLImporter::ReadMesh(XmlNode &node, TempScope &scope, bool &empty) { + TempMesh t; + + std::map<unsigned int, TempMaterialMesh> bymat; + const unsigned int mesh_id = ReadIDAttr(node); + bool empty_mesh = true; + for (XmlNode &child : node.children()) { + const std::string &s = ai_stdStrToLower(child.name()); + + if (s == "mat") { + ReadMaterial(child, scope); + } else if (s == "p") { + pugi::xml_attribute attr = child.attribute("ID"); + if (attr.empty()) { + LogWarn("no ID attribute on <p>, ignoring"); + } else { + int id = attr.as_int(); + t.points[id] = ReadVec3(child); + } + } else if (s == "n") { + pugi::xml_attribute attr = child.attribute("ID"); + if (attr.empty()) { + LogWarn("no ID attribute on <n>, ignoring"); + } else { + int id = attr.as_int(); + t.normals[id] = ReadVec3(child); + } + } else if (s == "tc") { + pugi::xml_attribute attr = child.attribute("ID"); + if (attr.empty()) { + LogWarn("no ID attribute on <tc>, ignoring"); + } else { + int id = attr.as_int(); + t.uvs[id] = ReadVec2(child); + } + } else if (s == "f" || s == "l" || s == "p") { + const unsigned int vcount = s == "f" ? 3 : (s == "l" ? 2 : 1); + + unsigned int mid = ~0u; + TempFace tf[3]; + bool has[3] = { false }; + for (XmlNode &sub_child : child.children()) { + const std::string &scn = ai_stdStrToLower(sub_child.name()); + if (scn == "fv1" || scn == "lv1" || scn == "pv1") { + ReadFaceVertex(sub_child, t, tf[0]); + has[0] = true; + } else if (scn == "fv2" || scn == "lv2") { + ReadFaceVertex(sub_child, t, tf[1]); + has[1] = true; + } else if (scn == "fv3") { + ReadFaceVertex(sub_child, t, tf[2]); + has[2] = true; + } else if (scn == "mat") { + if (mid != ~0u) { + LogWarn("only one material tag allowed per <f>"); + } + mid = ResolveMaterialRef(sub_child, scope); + } else if (scn == "matref") { + if (mid != ~0u) { + LogWarn("only one material tag allowed per <f>"); + } + mid = ResolveMaterialRef(sub_child, scope); + } + } + if (has[0] || has[1] || has[2]) { + empty_mesh = false; + } + + if (mid == ~0u) { + ThrowException("missing material index"); + } + + bool nor = false; + bool uv = false; + for (unsigned int i = 0; i < vcount; ++i) { + if (!has[i]) { + ThrowException("missing face vertex data"); + } + + nor = nor || tf[i].has_normal; + uv = uv || tf[i].has_uv; + } + + if (mid >= (1 << 30)) { + LogWarn("material indices exhausted, this may cause errors in the output"); + } + unsigned int meshId = mid | ((nor ? 1 : 0) << 31) | ((uv ? 1 : 0) << 30); + + TempMaterialMesh &mesh = bymat[meshId]; + mesh.matid = mid; + + for (unsigned int i = 0; i < vcount; ++i) { + mesh.positions.push_back(tf[i].pos); + if (nor) { + mesh.normals.push_back(tf[i].normal); + } + if (uv) { + mesh.uvs.push_back(tf[i].uv); + } + + mesh.pflags |= 1 << (vcount - 1); + } + + mesh.vcounts.push_back(vcount); + } + } + + // finally extract output meshes and add them to the scope + using pairt = std::pair<const unsigned int, TempMaterialMesh>; + for (const pairt &p : bymat) { + aiMesh *const m = ToOutputMesh(p.second); + scope.meshes_linear.push_back(m); + + // if this is a definition, keep it on the stack + if (mesh_id != ~0u) { + scope.meshes.insert(std::pair<unsigned int, aiMesh *>(mesh_id, m)); + } + } + if (empty_mesh) { + LogWarn("Mesh is empty, skipping."); + empty = empty_mesh; + return false; + } + + // no id == not a reference, insert this mesh right *here* + return mesh_id == ~0u; +} + +// ---------------------------------------------------------------------------------------------- +unsigned int XGLImporter::ResolveMaterialRef(XmlNode &node, TempScope &scope) { + const std::string &s = node.name(); + if (s == "mat") { + ReadMaterial(node, scope); + return static_cast<unsigned int>(scope.materials_linear.size() - 1); + } + + const int id = ReadIndexFromText(node); + + auto it = scope.materials.find(id), end = scope.materials.end(); + if (it == end) { + ThrowException("<matref> index out of range"); + } + + // ok, this is n^2 and should get optimized one day + aiMaterial *const m = it->second; + + unsigned int i = 0, mcount = static_cast<unsigned int>(scope.materials_linear.size()); + for (; i < mcount; ++i) { + if (scope.materials_linear[i] == m) { + return i; + } + } + + ai_assert(false); + + return 0; +} + +// ------------------------------------------------------------------------------------------------ +void XGLImporter::ReadMaterial(XmlNode &node, TempScope &scope) { + const unsigned int mat_id = ReadIDAttr(node); + + auto *mat(new aiMaterial); + for (XmlNode &child : node.children()) { + const std::string &s = ai_stdStrToLower(child.name()); + if (s == "amb") { + const aiColor3D c = ReadCol3(child); + mat->AddProperty(&c, 1, AI_MATKEY_COLOR_AMBIENT); + } else if (s == "diff") { + const aiColor3D c = ReadCol3(child); + mat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE); + } else if (s == "spec") { + const aiColor3D c = ReadCol3(child); + mat->AddProperty(&c, 1, AI_MATKEY_COLOR_SPECULAR); + } else if (s == "emiss") { + const aiColor3D c = ReadCol3(child); + mat->AddProperty(&c, 1, AI_MATKEY_COLOR_EMISSIVE); + } else if (s == "alpha") { + const float f = ReadFloat(child); + mat->AddProperty(&f, 1, AI_MATKEY_OPACITY); + } else if (s == "shine") { + const float f = ReadFloat(child); + mat->AddProperty(&f, 1, AI_MATKEY_SHININESS); + } + } + + scope.materials[mat_id] = mat; + scope.materials_linear.push_back(mat); +} + +// ---------------------------------------------------------------------------------------------- +void XGLImporter::ReadFaceVertex(XmlNode &node, const TempMesh &t, TempFace &out) { + bool havep = false; + for (XmlNode &child : node.children()) { + const std::string &s = ai_stdStrToLower(child.name()); + if (s == "pref") { + const unsigned int id = ReadIndexFromText(child); + std::map<unsigned int, aiVector3D>::const_iterator it = t.points.find(id); + if (it == t.points.end()) { + ThrowException("point index out of range"); + } + + out.pos = (*it).second; + havep = true; + } else if (s == "nref") { + const unsigned int id = ReadIndexFromText(child); + std::map<unsigned int, aiVector3D>::const_iterator it = t.normals.find(id); + if (it == t.normals.end()) { + ThrowException("normal index out of range"); + } + + out.normal = (*it).second; + out.has_normal = true; + } else if (s == "tcref") { + const unsigned int id = ReadIndexFromText(child); + std::map<unsigned int, aiVector2D>::const_iterator it = t.uvs.find(id); + if (it == t.uvs.end()) { + ThrowException("uv index out of range"); + } + + out.uv = (*it).second; + out.has_uv = true; + } else if (s == "p") { + out.pos = ReadVec3(child); + } else if (s == "n") { + out.normal = ReadVec3(child); + } else if (s == "tc") { + out.uv = ReadVec2(child); + } + } + + if (!havep) { + ThrowException("missing <pref> in <fvN> element"); + } +} + +// ------------------------------------------------------------------------------------------------ +unsigned int XGLImporter::ReadIDAttr(XmlNode &node) { + for (pugi::xml_attribute attr : node.attributes()) { + if (!ASSIMP_stricmp(attr.name(), "id")) { + return attr.as_int(); + } + } + + return ~0u; +} + +// ------------------------------------------------------------------------------------------------ +float XGLImporter::ReadFloat(XmlNode &node) { + std::string v; + XmlParser::getValueAsString(node, v); + const char *s = v.c_str(), *se; + if (!SkipSpaces(&s)) { + LogError("unexpected EOL, failed to parse index element"); + return 0.f; + } + float t; + se = fast_atoreal_move(s, t); + if (se == s) { + LogError("failed to read float text"); + return 0.f; + } + + return t; +} + +// ------------------------------------------------------------------------------------------------ +unsigned int XGLImporter::ReadIndexFromText(XmlNode &node) { + std::string v; + XmlParser::getValueAsString(node, v); + const char *s = v.c_str(); + if (!SkipSpaces(&s)) { + LogError("unexpected EOL, failed to parse index element"); + return ~0u; + } + const char *se; + const unsigned int t = strtoul10(s, &se); + + if (se == s) { + LogError("failed to read index"); + return ~0u; + } + + return t; +} + +// ------------------------------------------------------------------------------------------------ +aiVector2D XGLImporter::ReadVec2(XmlNode &node) { + aiVector2D vec; + std::string val; + XmlParser::getValueAsString(node, val); + const char *s = val.c_str(); + ai_real v[2] = {}; + for (int i = 0; i < 2; ++i) { + if (!SkipSpaces(&s)) { + LogError("unexpected EOL, failed to parse vec2"); + return vec; + } + + v[i] = fast_atof(&s); + + SkipSpaces(&s); + if (i != 1 && *s != ',') { + LogError("expected comma, failed to parse vec2"); + return vec; + } + ++s; + } + vec.x = v[0]; + vec.y = v[1]; + + return vec; +} + +// ------------------------------------------------------------------------------------------------ +aiVector3D XGLImporter::ReadVec3(XmlNode &node) { + aiVector3D vec; + std::string v; + XmlParser::getValueAsString(node, v); + const char *s = v.c_str(); + for (int i = 0; i < 3; ++i) { + if (!SkipSpaces(&s)) { + LogError("unexpected EOL, failed to parse vec3"); + return vec; + } + vec[i] = fast_atof(&s); + + SkipSpaces(&s); + if (i != 2 && *s != ',') { + LogError("expected comma, failed to parse vec3"); + return vec; + } + ++s; + } + + return vec; +} + +// ------------------------------------------------------------------------------------------------ +aiColor3D XGLImporter::ReadCol3(XmlNode &node) { + const aiVector3D &v = ReadVec3(node); + if (v.x < 0.f || v.x > 1.0f || v.y < 0.f || v.y > 1.0f || v.z < 0.f || v.z > 1.0f) { + LogWarn("color values out of range, ignoring"); + } + return aiColor3D(v.x, v.y, v.z); +} + +#endif // ASSIMP_BUILD_NO_XGL_IMPORTER diff --git a/libs/assimp/code/AssetLib/XGL/XGLLoader.h b/libs/assimp/code/AssetLib/XGL/XGLLoader.h new file mode 100644 index 0000000..ae7ccdd --- /dev/null +++ b/libs/assimp/code/AssetLib/XGL/XGLLoader.h @@ -0,0 +1,209 @@ +/* +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 XGLLoader.h + * @brief Declaration of the .xgl/.zgl + */ +#ifndef AI_XGLLOADER_H_INCLUDED +#define AI_XGLLOADER_H_INCLUDED + +#include <assimp/BaseImporter.h> +#include <assimp/XmlParser.h> +#include <assimp/LogAux.h> +#include <assimp/light.h> +#include <assimp/material.h> +#include <assimp/mesh.h> +#include <assimp/light.h> +#include <assimp/Importer.hpp> +#include <assimp/XmlParser.h> + +#include <map> +#include <memory> + +struct aiNode; + +namespace Assimp { + +// --------------------------------------------------------------------------- +/** XGL/ZGL importer. + * + * Spec: http://vizstream.aveva.com/release/vsplatform/XGLSpec.htm + */ +class XGLImporter : public BaseImporter, public LogFunctions<XGLImporter> { +public: + XGLImporter(); + ~XGLImporter() override; + + // ------------------------------------------------------------------- + /** Returns whether the class can handle the format of the given file. + * See BaseImporter::CanRead() for details. */ + bool CanRead(const std::string &pFile, IOSystem *pIOHandler, + bool checkSig) const override; + +protected: + // ------------------------------------------------------------------- + /** Return importer meta information. + * See #BaseImporter::GetInfo for the details */ + const aiImporterDesc *GetInfo() const override; + + // ------------------------------------------------------------------- + /** Imports the given file into the given scene structure. + * See BaseImporter::InternReadFile() for details */ + void InternReadFile(const std::string &pFile, aiScene *pScene, + IOSystem *pIOHandler) override; + +private: + struct TempScope { + TempScope() : + light() { + // empty + } + + ~TempScope() { + for (aiMesh *m : meshes_linear) { + delete m; + } + + for (aiMaterial *m : materials_linear) { + delete m; + } + + delete light; + } + + void dismiss() { + light = nullptr; + meshes_linear.clear(); + materials_linear.clear(); + meshes.clear(); + materials.clear(); + } + + std::multimap<unsigned int, aiMesh *> meshes; + std::map<unsigned int, aiMaterial *> materials; + + std::vector<aiMesh *> meshes_linear; + std::vector<aiMaterial *> materials_linear; + + aiLight *light; + }; + + struct SortMeshByMaterialId { + SortMeshByMaterialId(const TempScope &scope) : + scope(scope) { + // empty + } + bool operator()(unsigned int a, unsigned int b) const { + return scope.meshes_linear[a]->mMaterialIndex < scope.meshes_linear[b]->mMaterialIndex; + }; + + const TempScope &scope; + }; + + struct TempMesh { + std::map<unsigned int, aiVector3D> points; + std::map<unsigned int, aiVector3D> normals; + std::map<unsigned int, aiVector2D> uvs; + }; + + struct TempMaterialMesh { + TempMaterialMesh() : + pflags(), + matid() { + // empty + } + + std::vector<aiVector3D> positions, normals; + std::vector<aiVector2D> uvs; + + std::vector<unsigned int> vcounts; + unsigned int pflags; + unsigned int matid; + }; + + struct TempFace { + TempFace() : + has_uv(), + has_normal() { + // empty + } + + aiVector3D pos; + aiVector3D normal; + aiVector2D uv; + bool has_uv; + bool has_normal; + }; + +private: + void Cleanup(); + + std::string GetElementName(); + bool ReadElement(); + bool ReadElementUpToClosing(const char *closetag); + bool SkipToText(); + unsigned int ReadIDAttr(XmlNode &node); + + void ReadWorld(XmlNode &node, TempScope &scope); + void ReadLighting(XmlNode &node, TempScope &scope); + aiLight *ReadDirectionalLight(XmlNode &node); + aiNode *ReadObject(XmlNode &node, TempScope &scope); + bool ReadMesh(XmlNode &node, TempScope &scope, bool &empty); + void ReadMaterial(XmlNode &node, TempScope &scope); + aiVector2D ReadVec2(XmlNode &node); + aiVector3D ReadVec3(XmlNode &node); + aiColor3D ReadCol3(XmlNode &node); + aiMatrix4x4 ReadTrafo(XmlNode &node); + unsigned int ReadIndexFromText(XmlNode &node); + float ReadFloat(XmlNode &node); + + aiMesh *ToOutputMesh(const TempMaterialMesh &m); + void ReadFaceVertex(XmlNode &node, const TempMesh &t, TempFace &out); + unsigned int ResolveMaterialRef(XmlNode &node, TempScope &scope); + +private: + XmlParser *mXmlParser; + aiScene *m_scene; +}; + +} // end of namespace Assimp + +#endif // AI_IRRMESHIMPORTER_H_INC |