From 8fb7916a0d0cb007a4c3a4e6a31af58765268ca3 Mon Sep 17 00:00:00 2001 From: sanine Date: Sat, 16 Apr 2022 11:55:54 -0500 Subject: delete src/mesh/assimp-master --- .../code/AssetLib/Collada/ColladaExporter.cpp | 1748 -------------- .../code/AssetLib/Collada/ColladaExporter.h | 257 --- .../code/AssetLib/Collada/ColladaHelper.cpp | 99 - .../code/AssetLib/Collada/ColladaHelper.h | 679 ------ .../code/AssetLib/Collada/ColladaLoader.cpp | 1828 --------------- .../code/AssetLib/Collada/ColladaLoader.h | 249 -- .../code/AssetLib/Collada/ColladaParser.cpp | 2402 -------------------- .../code/AssetLib/Collada/ColladaParser.h | 348 --- 8 files changed, 7610 deletions(-) delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp delete mode 100644 src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h (limited to 'src/mesh/assimp-master/code/AssetLib/Collada') diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp deleted file mode 100644 index 5c91daa..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.cpp +++ /dev/null @@ -1,1748 +0,0 @@ -/* -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. - ----------------------------------------------------------------------- -*/ - -#ifndef ASSIMP_BUILD_NO_EXPORT -#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER - -#include "ColladaExporter.h" - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -namespace Assimp { - -// ------------------------------------------------------------------------------------------------ -// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp -void ExportSceneCollada(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) { - std::string path = DefaultIOSystem::absolutePath(std::string(pFile)); - std::string file = DefaultIOSystem::completeBaseName(std::string(pFile)); - - // invoke the exporter - ColladaExporter iDoTheExportThing(pScene, pIOSystem, path, file); - - if (iDoTheExportThing.mOutput.fail()) { - throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile)); - } - - // we're still here - export successfully completed. Write result to the given IOSYstem - std::unique_ptr outfile(pIOSystem->Open(pFile, "wt")); - if (outfile == nullptr) { - throw DeadlyExportError("could not open output .dae file: " + std::string(pFile)); - } - - // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy. - outfile->Write(iDoTheExportThing.mOutput.str().c_str(), static_cast(iDoTheExportThing.mOutput.tellp()), 1); -} - -// ------------------------------------------------------------------------------------------------ -// Encodes a string into a valid XML ID using the xsd:ID schema qualifications. -static const std::string XMLIDEncode(const std::string &name) { - const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-."; - const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char); - - if (name.length() == 0) { - return name; - } - - std::stringstream idEncoded; - - // xsd:ID must start with letter or underscore - if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) { - idEncoded << '_'; - } - - for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) { - // xsd:ID can only contain letters, digits, underscores, hyphens and periods - if (strchr(XML_ID_CHARS, *it) != nullptr) { - idEncoded << *it; - } else { - // Select placeholder character based on invalid character to reduce ID collisions - idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT]; - } - } - - return idEncoded.str(); -} - -// ------------------------------------------------------------------------------------------------ -// Helper functions to create unique ids -inline bool IsUniqueId(const std::unordered_set &idSet, const std::string &idStr) { - return (idSet.find(idStr) == idSet.end()); -} - -inline std::string MakeUniqueId(const std::unordered_set &idSet, const std::string &idPrefix, const std::string &postfix) { - std::string result(idPrefix + postfix); - if (!IsUniqueId(idSet, result)) { - // Select a number to append - size_t idnum = 1; - do { - result = idPrefix + '_' + ai_to_string(idnum) + postfix; - ++idnum; - } while (!IsUniqueId(idSet, result)); - } - return result; -} - -// ------------------------------------------------------------------------------------------------ -// Constructor for a specific scene to export -ColladaExporter::ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file) : - mIOSystem(pIOSystem), - mPath(path), - mFile(file), - mScene(pScene), - endstr("\n") { - // make sure that all formatting happens using the standard, C locale and not the user's current locale - mOutput.imbue(std::locale("C")); - mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION); - - // start writing the file - WriteFile(); -} - -// ------------------------------------------------------------------------------------------------ -// Destructor -ColladaExporter::~ColladaExporter() { -} - -// ------------------------------------------------------------------------------------------------ -// Starts writing the contents -void ColladaExporter::WriteFile() { - // write the DTD - mOutput << "" << endstr; - // COLLADA element start - mOutput << "" << endstr; - PushTag(); - - WriteTextures(); - WriteHeader(); - - // Add node names to the unique id database first so they are most likely to use their names as unique ids - CreateNodeIds(mScene->mRootNode); - - WriteCamerasLibrary(); - WriteLightsLibrary(); - WriteMaterials(); - WriteGeometryLibrary(); - WriteControllerLibrary(); - - WriteSceneLibrary(); - - // customized, Writes the animation library - WriteAnimationsLibrary(); - - // instantiate the scene(s) - // For Assimp there will only ever be one - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Writes the asset header -void ColladaExporter::WriteHeader() { - static const ai_real epsilon = Math::getEpsilon(); - static const aiQuaternion x_rot(aiMatrix3x3( - 0, -1, 0, - 1, 0, 0, - 0, 0, 1)); - static const aiQuaternion y_rot(aiMatrix3x3( - 1, 0, 0, - 0, 1, 0, - 0, 0, 1)); - static const aiQuaternion z_rot(aiMatrix3x3( - 1, 0, 0, - 0, 0, 1, - 0, -1, 0)); - - static const unsigned int date_nb_chars = 20; - char date_str[date_nb_chars]; - std::time_t date = std::time(nullptr); - std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date)); - - aiVector3D scaling; - aiQuaternion rotation; - aiVector3D position; - mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position); - rotation.Normalize(); - - mAdd_root_node = false; - - ai_real scale = 1.0; - if (std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) { - scale = (ai_real)((((double)scaling.x) + ((double)scaling.y) + ((double)scaling.z)) / 3.0); - } else { - mAdd_root_node = true; - } - - std::string up_axis = "Y_UP"; - if (rotation.Equal(x_rot, epsilon)) { - up_axis = "X_UP"; - } else if (rotation.Equal(y_rot, epsilon)) { - up_axis = "Y_UP"; - } else if (rotation.Equal(z_rot, epsilon)) { - up_axis = "Z_UP"; - } else { - mAdd_root_node = true; - } - - if (!position.Equal(aiVector3D(0, 0, 0))) { - mAdd_root_node = true; - } - - // Assimp root nodes can have meshes, Collada Scenes cannot - if (mScene->mRootNode->mNumChildren == 0 || mScene->mRootNode->mMeshes != 0) { - mAdd_root_node = true; - } - - if (mAdd_root_node) { - up_axis = "Y_UP"; - scale = 1.0; - } - - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - - // If no Scene metadata, use root node metadata - aiMetadata *meta = mScene->mMetaData; - if (nullptr == meta) { - meta = mScene->mRootNode->mMetaData; - } - - aiString value; - if (!meta || !meta->Get("Author", value)) { - mOutput << startstr << "" - << "Assimp" - << "" << endstr; - } else { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - - if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) { - mOutput << startstr << "" - << "Assimp Exporter" - << "" << endstr; - } else { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - - if (meta) { - if (meta->Get("Comments", value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - if (meta->Get("SourceData", value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - } - - PopTag(); - mOutput << startstr << "" << endstr; - - if (nullptr == meta || !meta->Get("Created", value)) { - mOutput << startstr << "" << date_str << "" << endstr; - } else { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - - // Modified date is always the date saved - mOutput << startstr << "" << date_str << "" << endstr; - - if (meta) { - if (meta->Get("Keywords", value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - if (meta->Get("Revision", value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - if (meta->Get("Subject", value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - if (meta->Get("Title", value)) { - mOutput << startstr << "" << XMLEscape(value.C_Str()) << "" << endstr; - } - } - - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << up_axis << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Write the embedded textures -void ColladaExporter::WriteTextures() { - static const unsigned int buffer_size = 1024; - char str[buffer_size]; - - if (mScene->HasTextures()) { - for (unsigned int i = 0; i < mScene->mNumTextures; i++) { - // It would be great to be able to create a directory in portable standard C++, but it's not the case, - // so we just write the textures in the current directory. - - aiTexture *texture = mScene->mTextures[i]; - if (nullptr == texture) { - continue; - } - - ASSIMP_itoa10(str, buffer_size, i + 1); - - std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char *)texture->achFormatHint); - - std::unique_ptr outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb")); - if (outfile == nullptr) { - throw DeadlyExportError("could not open output texture file: " + mPath + name); - } - - if (texture->mHeight == 0) { - outfile->Write((void *)texture->pcData, texture->mWidth, 1); - } else { - Bitmap::Save(texture, outfile.get()); - } - - outfile->Flush(); - - textures.insert(std::make_pair(i, name)); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Write the embedded textures -void ColladaExporter::WriteCamerasLibrary() { - if (mScene->HasCameras()) { - - mOutput << startstr << "" << endstr; - PushTag(); - - for (size_t a = 0; a < mScene->mNumCameras; ++a) - WriteCamera(a); - - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -void ColladaExporter::WriteCamera(size_t pIndex) { - - const aiCamera *cam = mScene->mCameras[pIndex]; - const std::string cameraId = GetObjectUniqueId(AiObjectType::Camera, pIndex); - const std::string cameraName = GetObjectName(AiObjectType::Camera, pIndex); - - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - //assimp doesn't support the import of orthographic cameras! se we write - //always perspective - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << AI_RAD_TO_DEG(cam->mHorizontalFOV) - << "" << endstr; - mOutput << startstr << "" - << cam->mAspect - << "" << endstr; - mOutput << startstr << "" - << cam->mClipPlaneNear - << "" << endstr; - mOutput << startstr << "" - << cam->mClipPlaneFar - << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Write the embedded textures -void ColladaExporter::WriteLightsLibrary() { - if (mScene->HasLights()) { - - mOutput << startstr << "" << endstr; - PushTag(); - - for (size_t a = 0; a < mScene->mNumLights; ++a) - WriteLight(a); - - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -void ColladaExporter::WriteLight(size_t pIndex) { - - const aiLight *light = mScene->mLights[pIndex]; - const std::string lightId = GetObjectUniqueId(AiObjectType::Light, pIndex); - const std::string lightName = GetObjectName(AiObjectType::Light, pIndex); - - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - switch (light->mType) { - case aiLightSource_AMBIENT: - WriteAmbienttLight(light); - break; - case aiLightSource_DIRECTIONAL: - WriteDirectionalLight(light); - break; - case aiLightSource_POINT: - WritePointLight(light); - break; - case aiLightSource_SPOT: - WriteSpotLight(light); - break; - case aiLightSource_AREA: - case aiLightSource_UNDEFINED: - case _aiLightSource_Force32Bit: - break; - } - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; -} - -void ColladaExporter::WritePointLight(const aiLight *const light) { - const aiColor3D &color = light->mColorDiffuse; - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" - << color.r << " " << color.g << " " << color.b - << "" << endstr; - mOutput << startstr << "" - << light->mAttenuationConstant - << "" << endstr; - mOutput << startstr << "" - << light->mAttenuationLinear - << "" << endstr; - mOutput << startstr << "" - << light->mAttenuationQuadratic - << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; -} - -void ColladaExporter::WriteDirectionalLight(const aiLight *const light) { - const aiColor3D &color = light->mColorDiffuse; - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" - << color.r << " " << color.g << " " << color.b - << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; -} - -void ColladaExporter::WriteSpotLight(const aiLight *const light) { - - const aiColor3D &color = light->mColorDiffuse; - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" - << color.r << " " << color.g << " " << color.b - << "" << endstr; - mOutput << startstr << "" - << light->mAttenuationConstant - << "" << endstr; - mOutput << startstr << "" - << light->mAttenuationLinear - << "" << endstr; - mOutput << startstr << "" - << light->mAttenuationQuadratic - << "" << endstr; - /* - out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+ - srcLight->mFalloffAngle); - */ - - const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone); - mOutput << startstr << "" - << fallOffAngle - << "" << endstr; - double temp = light->mAngleOuterCone - light->mAngleInnerCone; - - temp = std::cos(temp); - temp = std::log(temp) / std::log(0.1); - temp = 1 / temp; - mOutput << startstr << "" - << temp - << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; -} - -void ColladaExporter::WriteAmbienttLight(const aiLight *const light) { - - const aiColor3D &color = light->mColorAmbient; - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" - << color.r << " " << color.g << " " << color.b - << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Reads a single surface entry from the given material keys -bool ColladaExporter::ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex) { - if (pSrcMat.GetTextureCount(pTexture) > 0) { - aiString texfile; - unsigned int uvChannel = 0; - pSrcMat.GetTexture(pTexture, 0, &texfile, nullptr, &uvChannel); - - std::string index_str(texfile.C_Str()); - - if (index_str.size() != 0 && index_str[0] == '*') { - unsigned int index; - - index_str = index_str.substr(1, std::string::npos); - - try { - index = (unsigned int)strtoul10_64(index_str.c_str()); - } catch (std::exception &error) { - throw DeadlyExportError(error.what()); - } - - std::map::const_iterator name = textures.find(index); - - if (name != textures.end()) { - poSurface.texture = name->second; - } else { - throw DeadlyExportError("could not find embedded texture at index " + index_str); - } - } else { - poSurface.texture = texfile.C_Str(); - } - - poSurface.channel = uvChannel; - poSurface.exist = true; - } else { - if (pKey) - poSurface.exist = pSrcMat.Get(pKey, static_cast(pType), static_cast(pIndex), poSurface.color) == aiReturn_SUCCESS; - } - return poSurface.exist; -} - -// ------------------------------------------------------------------------------------------------ -// Reimplementation of isalnum(,C locale), because AppVeyor does not see standard version. -static bool isalnum_C(char c) { - return (nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", c)); -} - -// ------------------------------------------------------------------------------------------------ -// Writes an image entry for the given surface -void ColladaExporter::WriteImageEntry(const Surface &pSurface, const std::string &imageId) { - if (!pSurface.texture.empty()) { - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << ""; - - // URL encode image file name first, then XML encode on top - std::stringstream imageUrlEncoded; - for (std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it) { - if (isalnum_C((unsigned char)*it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\') - imageUrlEncoded << *it; - else - imageUrlEncoded << '%' << std::hex << size_t((unsigned char)*it) << std::dec; - } - mOutput << XMLEscape(imageUrlEncoded.str()); - mOutput << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -// ------------------------------------------------------------------------------------------------ -// Writes a color-or-texture entry into an effect definition -void ColladaExporter::WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId) { - if (pSurface.exist) { - mOutput << startstr << "<" << pTypeName << ">" << endstr; - PushTag(); - if (pSurface.texture.empty()) { - mOutput << startstr << "" << pSurface.color.r << " " << pSurface.color.g << " " << pSurface.color.b << " " << pSurface.color.a << "" << endstr; - } else { - mOutput << startstr << "" << endstr; - } - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -// ------------------------------------------------------------------------------------------------ -// Writes the two parameters necessary for referencing a texture in an effect entry -void ColladaExporter::WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId) { - // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture - if (!pSurface.texture.empty()) { - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << materialId << "-" << pTypeName << "-image" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << materialId << "-" << pTypeName << "-surface" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -// ------------------------------------------------------------------------------------------------ -// Writes a scalar property -void ColladaExporter::WriteFloatEntry(const Property &pProperty, const std::string &pTypeName) { - if (pProperty.exist) { - mOutput << startstr << "<" << pTypeName << ">" << endstr; - PushTag(); - mOutput << startstr << "" << pProperty.value << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -// ------------------------------------------------------------------------------------------------ -// Writes the material setup -void ColladaExporter::WriteMaterials() { - std::vector materials; - materials.resize(mScene->mNumMaterials); - - /// collect all materials from the scene - size_t numTextures = 0; - for (size_t a = 0; a < mScene->mNumMaterials; ++a) { - Material &material = materials[a]; - material.id = GetObjectUniqueId(AiObjectType::Material, a); - material.name = GetObjectName(AiObjectType::Material, a); - - const aiMaterial &mat = *(mScene->mMaterials[a]); - aiShadingMode shading = aiShadingMode_Flat; - material.shading_model = "phong"; - if (mat.Get(AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) { - if (shading == aiShadingMode_Phong) { - material.shading_model = "phong"; - } else if (shading == aiShadingMode_Blinn) { - material.shading_model = "blinn"; - } else if (shading == aiShadingMode_NoShading) { - material.shading_model = "constant"; - } else if (shading == aiShadingMode_Gouraud) { - material.shading_model = "lambert"; - } - } - - if (ReadMaterialSurface(material.ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT)) - ++numTextures; - if (ReadMaterialSurface(material.diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE)) - ++numTextures; - if (ReadMaterialSurface(material.specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR)) - ++numTextures; - if (ReadMaterialSurface(material.emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE)) - ++numTextures; - if (ReadMaterialSurface(material.reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE)) - ++numTextures; - if (ReadMaterialSurface(material.transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT)) - ++numTextures; - if (ReadMaterialSurface(material.normal, mat, aiTextureType_NORMALS, nullptr, 0, 0)) - ++numTextures; - - material.shininess.exist = mat.Get(AI_MATKEY_SHININESS, material.shininess.value) == aiReturn_SUCCESS; - material.transparency.exist = mat.Get(AI_MATKEY_OPACITY, material.transparency.value) == aiReturn_SUCCESS; - material.index_refraction.exist = mat.Get(AI_MATKEY_REFRACTI, material.index_refraction.value) == aiReturn_SUCCESS; - } - - // output textures if present - if (numTextures > 0) { - mOutput << startstr << "" << endstr; - PushTag(); - for (const Material &mat : materials) { - WriteImageEntry(mat.ambient, mat.id + "-ambient-image"); - WriteImageEntry(mat.diffuse, mat.id + "-diffuse-image"); - WriteImageEntry(mat.specular, mat.id + "-specular-image"); - WriteImageEntry(mat.emissive, mat.id + "-emission-image"); - WriteImageEntry(mat.reflective, mat.id + "-reflective-image"); - WriteImageEntry(mat.transparent, mat.id + "-transparent-image"); - WriteImageEntry(mat.normal, mat.id + "-normal-image"); - } - PopTag(); - mOutput << startstr << "" << endstr; - } - - // output effects - those are the actual carriers of information - if (!materials.empty()) { - mOutput << startstr << "" << endstr; - PushTag(); - for (const Material &mat : materials) { - // this is so ridiculous it must be right - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - - // write sampler- and surface params for the texture entries - WriteTextureParamEntry(mat.emissive, "emission", mat.id); - WriteTextureParamEntry(mat.ambient, "ambient", mat.id); - WriteTextureParamEntry(mat.diffuse, "diffuse", mat.id); - WriteTextureParamEntry(mat.specular, "specular", mat.id); - WriteTextureParamEntry(mat.reflective, "reflective", mat.id); - WriteTextureParamEntry(mat.transparent, "transparent", mat.id); - WriteTextureParamEntry(mat.normal, "normal", mat.id); - - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "<" << mat.shading_model << ">" << endstr; - PushTag(); - - WriteTextureColorEntry(mat.emissive, "emission", mat.id + "-emission-sampler"); - WriteTextureColorEntry(mat.ambient, "ambient", mat.id + "-ambient-sampler"); - WriteTextureColorEntry(mat.diffuse, "diffuse", mat.id + "-diffuse-sampler"); - WriteTextureColorEntry(mat.specular, "specular", mat.id + "-specular-sampler"); - WriteFloatEntry(mat.shininess, "shininess"); - WriteTextureColorEntry(mat.reflective, "reflective", mat.id + "-reflective-sampler"); - WriteTextureColorEntry(mat.transparent, "transparent", mat.id + "-transparent-sampler"); - WriteFloatEntry(mat.transparency, "transparency"); - WriteFloatEntry(mat.index_refraction, "index_of_refraction"); - - if (!mat.normal.texture.empty()) { - WriteTextureColorEntry(mat.normal, "bump", mat.id + "-normal-sampler"); - } - - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } - PopTag(); - mOutput << startstr << "" << endstr; - - // write materials - they're just effect references - mOutput << startstr << "" << endstr; - PushTag(); - for (std::vector::const_iterator it = materials.begin(); it != materials.end(); ++it) { - const Material &mat = *it; - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } - PopTag(); - mOutput << startstr << "" << endstr; - } -} - -// ------------------------------------------------------------------------------------------------ -// Writes the controller library -void ColladaExporter::WriteControllerLibrary() { - mOutput << startstr << "" << endstr; - PushTag(); - - for (size_t a = 0; a < mScene->mNumMeshes; ++a) { - WriteController(a); - } - - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Writes a skin controller of the given mesh -void ColladaExporter::WriteController(size_t pIndex) { - const aiMesh *mesh = mScene->mMeshes[pIndex]; - // Is there a skin controller? - if (mesh->mNumBones == 0 || mesh->mNumFaces == 0 || mesh->mNumVertices == 0) - return; - - const std::string idstr = GetObjectUniqueId(AiObjectType::Mesh, pIndex); - const std::string namestr = GetObjectName(AiObjectType::Mesh, pIndex); - - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - PushTag(); - - // bind pose matrix - mOutput << startstr << "" << endstr; - PushTag(); - - // I think it is identity in general cases. - aiMatrix4x4 mat; - mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr; - mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr; - mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr; - mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "mNumBones << "\">"; - - for (size_t i = 0; i < mesh->mNumBones; ++i) - mOutput << GetBoneUniqueId(mesh->mBones[i]) << ' '; - - mOutput << "" << endstr; - - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "mNumBones << "\" stride=\"" << 1 << "\">" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - std::vector bind_poses; - bind_poses.reserve(mesh->mNumBones * 16); - for (unsigned int i = 0; i < mesh->mNumBones; ++i) - for (unsigned int j = 0; j < 4; ++j) - bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4); - - WriteFloatArray(idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real *)bind_poses.data(), bind_poses.size() / 16); - - bind_poses.clear(); - - std::vector skin_weights; - skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones); - for (size_t i = 0; i < mesh->mNumBones; ++i) - for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j) - skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight); - - WriteFloatArray(idstr + "-skin-weights", FloatType_Weight, (const ai_real *)skin_weights.data(), skin_weights.size()); - - skin_weights.clear(); - - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - mOutput << startstr << "mNumVertices << "\">" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - - mOutput << startstr << ""; - - std::vector num_influences(mesh->mNumVertices, (ai_uint)0); - for (size_t i = 0; i < mesh->mNumBones; ++i) - for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j) - ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId]; - - for (size_t i = 0; i < mesh->mNumVertices; ++i) - mOutput << num_influences[i] << " "; - - mOutput << "" << endstr; - - mOutput << startstr << ""; - - ai_uint joint_weight_indices_length = 0; - std::vector accum_influences; - accum_influences.reserve(num_influences.size()); - for (size_t i = 0; i < num_influences.size(); ++i) { - accum_influences.push_back(joint_weight_indices_length); - joint_weight_indices_length += num_influences[i]; - } - - ai_uint weight_index = 0; - std::vector joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1); - for (unsigned int i = 0; i < mesh->mNumBones; ++i) - for (unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j) { - unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId; - for (ai_uint k = 0; k < num_influences[vId]; ++k) { - if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1) { - joint_weight_indices[2 * (accum_influences[vId] + k)] = i; - joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index; - break; - } - } - ++weight_index; - } - - for (size_t i = 0; i < joint_weight_indices.size(); ++i) - mOutput << joint_weight_indices[i] << " "; - - num_influences.clear(); - accum_influences.clear(); - joint_weight_indices.clear(); - - mOutput << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Writes the geometry library -void ColladaExporter::WriteGeometryLibrary() { - mOutput << startstr << "" << endstr; - PushTag(); - - for (size_t a = 0; a < mScene->mNumMeshes; ++a) - WriteGeometry(a); - - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Writes the given mesh -void ColladaExporter::WriteGeometry(size_t pIndex) { - const aiMesh *mesh = mScene->mMeshes[pIndex]; - const std::string geometryId = GetObjectUniqueId(AiObjectType::Mesh, pIndex); - const std::string geometryName = GetObjectName(AiObjectType::Mesh, pIndex); - - if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0) - return; - - // opening tag - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - PushTag(); - - // Positions - WriteFloatArray(geometryId + "-positions", FloatType_Vector, (ai_real *)mesh->mVertices, mesh->mNumVertices); - // Normals, if any - if (mesh->HasNormals()) - WriteFloatArray(geometryId + "-normals", FloatType_Vector, (ai_real *)mesh->mNormals, mesh->mNumVertices); - - // texture coords - for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) { - if (mesh->HasTextureCoords(static_cast(a))) { - WriteFloatArray(geometryId + "-tex" + ai_to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2, - (ai_real *)mesh->mTextureCoords[a], mesh->mNumVertices); - } - } - - // vertex colors - for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) { - if (mesh->HasVertexColors(static_cast(a))) - WriteFloatArray(geometryId + "-color" + ai_to_string(a), FloatType_Color, (ai_real *)mesh->mColors[a], mesh->mNumVertices); - } - - // assemble vertex structure - // Only write input for POSITION since we will write other as shared inputs in polygon definition - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - - // count the number of lines, triangles and polygon meshes - int countLines = 0; - int countPoly = 0; - for (size_t a = 0; a < mesh->mNumFaces; ++a) { - if (mesh->mFaces[a].mNumIndices == 2) - countLines++; - else if (mesh->mFaces[a].mNumIndices >= 3) - countPoly++; - } - - // lines - if (countLines) { - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - if (mesh->HasNormals()) - mOutput << startstr << "" << endstr; - for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) { - if (mesh->HasTextureCoords(static_cast(a))) - mOutput << startstr << "" << endstr; - } - for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) { - if (mesh->HasVertexColors(static_cast(a))) - mOutput << startstr << "" << endstr; - } - - mOutput << startstr << "

"; - for (size_t a = 0; a < mesh->mNumFaces; ++a) { - const aiFace &face = mesh->mFaces[a]; - if (face.mNumIndices != 2) continue; - for (size_t b = 0; b < face.mNumIndices; ++b) - mOutput << face.mIndices[b] << " "; - } - mOutput << "

" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } - - // triangle - don't use it, because compatibility problems - - // polygons - if (countPoly) { - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - if (mesh->HasNormals()) - mOutput << startstr << "" << endstr; - for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) { - if (mesh->HasTextureCoords(static_cast(a))) - mOutput << startstr << "" << endstr; - } - for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) { - if (mesh->HasVertexColors(static_cast(a))) - mOutput << startstr << "" << endstr; - } - - mOutput << startstr << ""; - for (size_t a = 0; a < mesh->mNumFaces; ++a) { - if (mesh->mFaces[a].mNumIndices < 3) continue; - mOutput << mesh->mFaces[a].mNumIndices << " "; - } - mOutput << "" << endstr; - - mOutput << startstr << "

"; - for (size_t a = 0; a < mesh->mNumFaces; ++a) { - const aiFace &face = mesh->mFaces[a]; - if (face.mNumIndices < 3) continue; - for (size_t b = 0; b < face.mNumIndices; ++b) - mOutput << face.mIndices[b] << " "; - } - mOutput << "

" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - } - - // closing tags - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Writes a float array of the given type -void ColladaExporter::WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount) { - size_t floatsPerElement = 0; - switch (pType) { - case FloatType_Vector: floatsPerElement = 3; break; - case FloatType_TexCoord2: floatsPerElement = 2; break; - case FloatType_TexCoord3: floatsPerElement = 3; break; - case FloatType_Color: floatsPerElement = 3; break; - case FloatType_Mat4x4: floatsPerElement = 16; break; - case FloatType_Weight: floatsPerElement = 1; break; - case FloatType_Time: floatsPerElement = 1; break; - default: - return; - } - - std::string arrayId = XMLIDEncode(pIdString) + "-array"; - - mOutput << startstr << "" << endstr; - PushTag(); - - // source array - mOutput << startstr << " "; - PushTag(); - - if (pType == FloatType_TexCoord2) { - for (size_t a = 0; a < pElementCount; ++a) { - mOutput << pData[a * 3 + 0] << " "; - mOutput << pData[a * 3 + 1] << " "; - } - } else if (pType == FloatType_Color) { - for (size_t a = 0; a < pElementCount; ++a) { - mOutput << pData[a * 4 + 0] << " "; - mOutput << pData[a * 4 + 1] << " "; - mOutput << pData[a * 4 + 2] << " "; - } - } else { - for (size_t a = 0; a < pElementCount * floatsPerElement; ++a) - mOutput << pData[a] << " "; - } - mOutput << "" << endstr; - PopTag(); - - // the usual Collada fun. Let's bloat it even more! - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - - switch (pType) { - case FloatType_Vector: - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - break; - - case FloatType_TexCoord2: - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - break; - - case FloatType_TexCoord3: - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - break; - - case FloatType_Color: - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - mOutput << startstr << "" << endstr; - break; - - case FloatType_Mat4x4: - mOutput << startstr << "" << endstr; - break; - - case FloatType_Weight: - mOutput << startstr << "" << endstr; - break; - - // customized, add animation related - case FloatType_Time: - mOutput << startstr << "" << endstr; - break; - } - - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; -} - -// ------------------------------------------------------------------------------------------------ -// Writes the scene library -void ColladaExporter::WriteSceneLibrary() { - // Determine if we are using the aiScene root or our own - std::string sceneName("Scene"); - if (mAdd_root_node) { - mSceneId = MakeUniqueId(mUniqueIds, sceneName, std::string()); - mUniqueIds.insert(mSceneId); - } else { - mSceneId = GetNodeUniqueId(mScene->mRootNode); - sceneName = GetNodeName(mScene->mRootNode); - } - - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - - if (mAdd_root_node) { - // Export the root node - WriteNode(mScene->mRootNode); - } else { - // Have already exported the root node - for (size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a) - WriteNode(mScene->mRootNode->mChildren[a]); - } - - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; -} -// ------------------------------------------------------------------------------------------------ -void ColladaExporter::WriteAnimationLibrary(size_t pIndex) { - const aiAnimation *anim = mScene->mAnimations[pIndex]; - - if (anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels == 0) - return; - - const std::string animationNameEscaped = GetObjectName(AiObjectType::Animation, pIndex); - const std::string idstrEscaped = GetObjectUniqueId(AiObjectType::Animation, pIndex); - - mOutput << startstr << "" << endstr; - PushTag(); - - std::string cur_node_idstr; - for (size_t a = 0; a < anim->mNumChannels; ++a) { - const aiNodeAnim *nodeAnim = anim->mChannels[a]; - - // sanity check - if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) { - continue; - } - - { - cur_node_idstr.clear(); - cur_node_idstr += nodeAnim->mNodeName.data; - cur_node_idstr += std::string("_matrix-input"); - - std::vector frames; - for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) { - frames.push_back(static_cast(nodeAnim->mPositionKeys[i].mTime)); - } - - WriteFloatArray(cur_node_idstr, FloatType_Time, (const ai_real *)frames.data(), frames.size()); - frames.clear(); - } - - { - cur_node_idstr.clear(); - - cur_node_idstr += nodeAnim->mNodeName.data; - cur_node_idstr += std::string("_matrix-output"); - - std::vector keyframes; - keyframes.reserve(nodeAnim->mNumPositionKeys * 16); - for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) { - aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue; - aiMatrix4x4 ScalingM; // identity - ScalingM[0][0] = Scaling.x; - ScalingM[1][1] = Scaling.y; - ScalingM[2][2] = Scaling.z; - - aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue; - aiMatrix4x4 s = aiMatrix4x4(RotationQ.GetMatrix()); - aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1); - - aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue; - aiMatrix4x4 TranslationM; // identity - TranslationM[0][3] = Translation.x; - TranslationM[1][3] = Translation.y; - TranslationM[2][3] = Translation.z; - - // Combine the above transformations - aiMatrix4x4 mat = TranslationM * RotationM * ScalingM; - - for (unsigned int j = 0; j < 4; ++j) { - keyframes.insert(keyframes.end(), mat[j], mat[j] + 4); - } - } - - WriteFloatArray(cur_node_idstr, FloatType_Mat4x4, (const ai_real *)keyframes.data(), keyframes.size() / 16); - } - - { - std::vector names; - for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) { - if (nodeAnim->mPreState == aiAnimBehaviour_DEFAULT || nodeAnim->mPreState == aiAnimBehaviour_LINEAR || nodeAnim->mPreState == aiAnimBehaviour_REPEAT) { - names.push_back("LINEAR"); - } else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) { - names.push_back("STEP"); - } - } - - const std::string cur_node_idstr2 = nodeAnim->mNodeName.data + std::string("_matrix-interpolation"); - std::string arrayId = XMLIDEncode(cur_node_idstr2) + "-array"; - - mOutput << startstr << "" << endstr; - PushTag(); - - // source array - mOutput << startstr << " "; - for (size_t aa = 0; aa < names.size(); ++aa) { - mOutput << names[aa] << " "; - } - mOutput << "" << endstr; - - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - } - } - - for (size_t a = 0; a < anim->mNumChannels; ++a) { - const aiNodeAnim *nodeAnim = anim->mChannels[a]; - - { - // samplers - const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler"); - mOutput << startstr << "" << endstr; - PushTag(); - - mOutput << startstr << "mNodeName.data + std::string("_matrix-input")) << "\"/>" << endstr; - mOutput << startstr << "mNodeName.data + std::string("_matrix-output")) << "\"/>" << endstr; - mOutput << startstr << "mNodeName.data + std::string("_matrix-interpolation")) << "\"/>" << endstr; - - PopTag(); - mOutput << startstr << "" << endstr; - } - } - - for (size_t a = 0; a < anim->mNumChannels; ++a) { - const aiNodeAnim *nodeAnim = anim->mChannels[a]; - - { - // channels - mOutput << startstr << "mNodeName.data + std::string("_matrix-sampler")) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr; - } - } - - PopTag(); - mOutput << startstr << "" << endstr; -} -// ------------------------------------------------------------------------------------------------ -void ColladaExporter::WriteAnimationsLibrary() { - if (mScene->mNumAnimations > 0) { - mOutput << startstr << "" << endstr; - PushTag(); - - // start recursive write at the root node - for (size_t a = 0; a < mScene->mNumAnimations; ++a) - WriteAnimationLibrary(a); - - PopTag(); - mOutput << startstr << "" << endstr; - } -} -// ------------------------------------------------------------------------------------------------ -// Helper to find a bone by name in the scene -aiBone *findBone(const aiScene *scene, const aiString &name) { - for (size_t m = 0; m < scene->mNumMeshes; m++) { - aiMesh *mesh = scene->mMeshes[m]; - for (size_t b = 0; b < mesh->mNumBones; b++) { - aiBone *bone = mesh->mBones[b]; - if (name == bone->mName) { - return bone; - } - } - } - return nullptr; -} - -// ------------------------------------------------------------------------------------------------ -// Helper to find the node associated with a bone in the scene -const aiNode *findBoneNode(const aiNode *aNode, const aiBone *bone) { - if (aNode && bone && aNode->mName == bone->mName) { - return aNode; - } - - if (aNode && bone) { - for (unsigned int i = 0; i < aNode->mNumChildren; ++i) { - aiNode *aChild = aNode->mChildren[i]; - const aiNode *foundFromChild = nullptr; - if (aChild) { - foundFromChild = findBoneNode(aChild, bone); - if (foundFromChild) { - return foundFromChild; - } - } - } - } - - return nullptr; -} - -const aiNode *findSkeletonRootNode(const aiScene *scene, const aiMesh *mesh) { - std::set topParentBoneNodes; - if (mesh && mesh->mNumBones > 0) { - for (unsigned int i = 0; i < mesh->mNumBones; ++i) { - aiBone *bone = mesh->mBones[i]; - - const aiNode *node = findBoneNode(scene->mRootNode, bone); - if (node) { - while (node->mParent && findBone(scene, node->mParent->mName) != nullptr) { - node = node->mParent; - } - topParentBoneNodes.insert(node); - } - } - } - - if (!topParentBoneNodes.empty()) { - const aiNode *parentBoneNode = *topParentBoneNodes.begin(); - if (topParentBoneNodes.size() == 1) { - return parentBoneNode; - } else { - for (auto it : topParentBoneNodes) { - if (it->mParent) return it->mParent; - } - return parentBoneNode; - } - } - - return nullptr; -} - -// ------------------------------------------------------------------------------------------------ -// Recursively writes the given node -void ColladaExporter::WriteNode(const aiNode *pNode) { - // If the node is associated with a bone, it is a joint node (JOINT) - // otherwise it is a normal node (NODE) - // Assimp-specific: nodes with no name cannot be associated with bones - const char *node_type; - bool is_joint, is_skeleton_root = false; - if (pNode->mName.length == 0 || nullptr == findBone(mScene, pNode->mName)) { - node_type = "NODE"; - is_joint = false; - } else { - node_type = "JOINT"; - is_joint = true; - if (!pNode->mParent || nullptr == findBone(mScene, pNode->mParent->mName)) { - is_skeleton_root = true; - } - } - - const std::string node_id = GetNodeUniqueId(pNode); - const std::string node_name = GetNodeName(pNode); - mOutput << startstr << "" << endstr; - PushTag(); - - // write transformation - we can directly put the matrix there - // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards - aiMatrix4x4 mat = pNode->mTransformation; - - // If this node is a Camera node, the camera coordinate system needs to be multiplied in. - // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged. - // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera - // coordinate system must be changed to matche the Collada specification. - for (size_t i = 0; i < mScene->mNumCameras; i++) { - if (mScene->mCameras[i]->mName == pNode->mName) { - aiMatrix4x4 sourceView; - mScene->mCameras[i]->GetCameraMatrix(sourceView); - - aiMatrix4x4 colladaView; - colladaView.a1 = colladaView.c3 = -1; // move into -z space. - mat *= (sourceView * colladaView); - break; - } - } - - // customized, sid should be 'matrix' to match with loader code. - //mOutput << startstr << ""; - mOutput << startstr << ""; - - mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " "; - mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " "; - mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " "; - mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4; - mOutput << "" << endstr; - - if (pNode->mNumMeshes == 0) { - //check if it is a camera node - for (size_t i = 0; i < mScene->mNumCameras; i++) { - if (mScene->mCameras[i]->mName == pNode->mName) { - mOutput << startstr << "" << endstr; - break; - } - } - //check if it is a light node - for (size_t i = 0; i < mScene->mNumLights; i++) { - if (mScene->mLights[i]->mName == pNode->mName) { - mOutput << startstr << "" << endstr; - break; - } - } - - } else - // instance every geometry - for (size_t a = 0; a < pNode->mNumMeshes; ++a) { - const aiMesh *mesh = mScene->mMeshes[pNode->mMeshes[a]]; - // do not instantiate mesh if empty. I wonder how this could happen - if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0) - continue; - - const std::string meshId = GetObjectUniqueId(AiObjectType::Mesh, pNode->mMeshes[a]); - - if (mesh->mNumBones == 0) { - mOutput << startstr << "" << endstr; - PushTag(); - } else { - mOutput << startstr - << "" - << endstr; - PushTag(); - - // note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node. - // use the first bone to find skeleton root - const aiNode *skeletonRootBoneNode = findSkeletonRootNode(mScene, mesh); - if (skeletonRootBoneNode) { - mFoundSkeletonRootNodeID = GetNodeUniqueId(skeletonRootBoneNode); - } - mOutput << startstr << "#" << mFoundSkeletonRootNodeID << "" << endstr; - } - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "" << endstr; - PushTag(); - mOutput << startstr << "mMaterialIndex) << "\">" << endstr; - PushTag(); - for (size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa) { - if (mesh->HasTextureCoords(static_cast(aa))) - // semantic as in - // input_semantic as in - // input_set as in - mOutput << startstr << "" << endstr; - } - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - PopTag(); - mOutput << startstr << "" << endstr; - - PopTag(); - if (mesh->mNumBones == 0) - mOutput << startstr << "" << endstr; - else - mOutput << startstr << "" << endstr; - } - - // recurse into subnodes - for (size_t a = 0; a < pNode->mNumChildren; ++a) - WriteNode(pNode->mChildren[a]); - - PopTag(); - mOutput << startstr << "" << endstr; -} - -void ColladaExporter::CreateNodeIds(const aiNode *node) { - GetNodeUniqueId(node); - for (size_t a = 0; a < node->mNumChildren; ++a) - CreateNodeIds(node->mChildren[a]); -} - -std::string ColladaExporter::GetNodeUniqueId(const aiNode *node) { - // Use the pointer as the key. This is safe because the scene is immutable. - auto idIt = mNodeIdMap.find(node); - if (idIt != mNodeIdMap.cend()) - return idIt->second; - - // Prefer the requested Collada Id if extant - std::string idStr; - aiString origId; - if (node->mMetaData && node->mMetaData->Get(AI_METADATA_COLLADA_ID, origId)) { - idStr = origId.C_Str(); - } else { - idStr = node->mName.C_Str(); - } - // Make sure the requested id is valid - if (idStr.empty()) - idStr = "node"; - else - idStr = XMLIDEncode(idStr); - - // Ensure it's unique - idStr = MakeUniqueId(mUniqueIds, idStr, std::string()); - mUniqueIds.insert(idStr); - mNodeIdMap.insert(std::make_pair(node, idStr)); - return idStr; -} - -std::string ColladaExporter::GetNodeName(const aiNode *node) { - - return XMLEscape(node->mName.C_Str()); -} - -std::string ColladaExporter::GetBoneUniqueId(const aiBone *bone) { - // Find the Node that is this Bone - const aiNode *boneNode = findBoneNode(mScene->mRootNode, bone); - if (boneNode == nullptr) - return std::string(); - - return GetNodeUniqueId(boneNode); -} - -std::string ColladaExporter::GetObjectUniqueId(AiObjectType type, size_t pIndex) { - auto idIt = GetObjectIdMap(type).find(pIndex); - if (idIt != GetObjectIdMap(type).cend()) - return idIt->second; - - // Not seen this object before, create and add - NameIdPair result = AddObjectIndexToMaps(type, pIndex); - return result.second; -} - -std::string ColladaExporter::GetObjectName(AiObjectType type, size_t pIndex) { - auto objectName = GetObjectNameMap(type).find(pIndex); - if (objectName != GetObjectNameMap(type).cend()) - return objectName->second; - - // Not seen this object before, create and add - NameIdPair result = AddObjectIndexToMaps(type, pIndex); - return result.first; -} - -// Determine unique id and add the name and id to the maps -// @param type object type -// @param index object index -// @param name in/out. Caller to set the original name if known. -// @param idStr in/out. Caller to set the preferred id if known. -ColladaExporter::NameIdPair ColladaExporter::AddObjectIndexToMaps(AiObjectType type, size_t index) { - - std::string name; - std::string idStr; - std::string idPostfix; - - // Get the name and id postfix - switch (type) { - case AiObjectType::Mesh: name = mScene->mMeshes[index]->mName.C_Str(); break; - case AiObjectType::Material: name = mScene->mMaterials[index]->GetName().C_Str(); break; - case AiObjectType::Animation: name = mScene->mAnimations[index]->mName.C_Str(); break; - case AiObjectType::Light: - name = mScene->mLights[index]->mName.C_Str(); - idPostfix = "-light"; - break; - case AiObjectType::Camera: - name = mScene->mCameras[index]->mName.C_Str(); - idPostfix = "-camera"; - break; - case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type"); - } - - if (name.empty()) { - // Default ids if empty name - switch (type) { - case AiObjectType::Mesh: idStr = std::string("mesh_"); break; - case AiObjectType::Material: idStr = std::string("material_"); break; // This one should never happen - case AiObjectType::Animation: idStr = std::string("animation_"); break; - case AiObjectType::Light: idStr = std::string("light_"); break; - case AiObjectType::Camera: idStr = std::string("camera_"); break; - case AiObjectType::Count: throw std::logic_error("ColladaExporter::AiObjectType::Count is not an object type"); - } - idStr.append(ai_to_string(index)); - } else { - idStr = XMLIDEncode(name); - } - - if (!name.empty()) - name = XMLEscape(name); - - idStr = MakeUniqueId(mUniqueIds, idStr, idPostfix); - - // Add to maps - mUniqueIds.insert(idStr); - GetObjectIdMap(type).insert(std::make_pair(index, idStr)); - GetObjectNameMap(type).insert(std::make_pair(index, name)); - - return std::make_pair(name, idStr); -} - -} // end of namespace Assimp - -#endif -#endif diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h deleted file mode 100644 index 56415fb..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaExporter.h +++ /dev/null @@ -1,257 +0,0 @@ -/* -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 ColladaExporter.h - * Declares the exporter class to write a scene to a Collada file - */ -#ifndef AI_COLLADAEXPORTER_H_INC -#define AI_COLLADAEXPORTER_H_INC - -#include -#include - -#include -#include -#include -#include -#include - -struct aiScene; -struct aiNode; -struct aiLight; -struct aiBone; - -namespace Assimp { - -class IOSystem; - -/// Helper class to export a given scene to a Collada file. Just for my personal -/// comfort when implementing it. -class ColladaExporter { -public: - /// Constructor for a specific scene to export - ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file); - - /// Destructor - virtual ~ColladaExporter(); - -protected: - /// Starts writing the contents - void WriteFile(); - - /// Writes the asset header - void WriteHeader(); - - /// Writes the embedded textures - void WriteTextures(); - - /// Writes the material setup - void WriteMaterials(); - - /// Writes the cameras library - void WriteCamerasLibrary(); - - // Write a camera entry - void WriteCamera(size_t pIndex); - - /// Writes the cameras library - void WriteLightsLibrary(); - - // Write a camera entry - void WriteLight(size_t pIndex); - void WritePointLight(const aiLight *const light); - void WriteDirectionalLight(const aiLight *const light); - void WriteSpotLight(const aiLight *const light); - void WriteAmbienttLight(const aiLight *const light); - - /// Writes the controller library - void WriteControllerLibrary(); - - /// Writes a skin controller of the given mesh - void WriteController(size_t pIndex); - - /// Writes the geometry library - void WriteGeometryLibrary(); - - /// Writes the given mesh - void WriteGeometry(size_t pIndex); - - //enum FloatDataType { FloatType_Vector, FloatType_TexCoord2, FloatType_TexCoord3, FloatType_Color, FloatType_Mat4x4, FloatType_Weight }; - // customized to add animation related type - enum FloatDataType { FloatType_Vector, - FloatType_TexCoord2, - FloatType_TexCoord3, - FloatType_Color, - FloatType_Mat4x4, - FloatType_Weight, - FloatType_Time }; - - /// Writes a float array of the given type - void WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount); - - /// Writes the scene library - void WriteSceneLibrary(); - - // customized, Writes the animation library - void WriteAnimationsLibrary(); - void WriteAnimationLibrary(size_t pIndex); - std::string mFoundSkeletonRootNodeID = "skeleton_root"; // will be replaced by found node id in the WriteNode call. - - /// Recursively writes the given node - void WriteNode(const aiNode *pNode); - - /// Enters a new xml element, which increases the indentation - void PushTag() { startstr.append(" "); } - /// Leaves an element, decreasing the indentation - void PopTag() { - ai_assert(startstr.length() > 1); - startstr.erase(startstr.length() - 2); - } - - void CreateNodeIds(const aiNode *node); - - /// Get or Create a unique Node ID string for the given Node - std::string GetNodeUniqueId(const aiNode *node); - std::string GetNodeName(const aiNode *node); - - std::string GetBoneUniqueId(const aiBone *bone); - - enum class AiObjectType { - Mesh, - Material, - Animation, - Light, - Camera, - Count, - }; - /// Get or Create a unique ID string for the given scene object index - std::string GetObjectUniqueId(AiObjectType type, size_t pIndex); - /// Get or Create a name string for the given scene object index - std::string GetObjectName(AiObjectType type, size_t pIndex); - - typedef std::map IndexIdMap; - typedef std::pair NameIdPair; - NameIdPair AddObjectIndexToMaps(AiObjectType type, size_t pIndex); - - // Helpers - inline IndexIdMap &GetObjectIdMap(AiObjectType type) { return mObjectIdMap[static_cast(type)]; } - inline IndexIdMap &GetObjectNameMap(AiObjectType type) { return mObjectNameMap[static_cast(type)]; } - -private: - std::unordered_set mUniqueIds; // Cache of used unique ids - std::map mNodeIdMap; // Cache of encoded node and bone ids - std::array(AiObjectType::Count)> mObjectIdMap; // Cache of encoded unique IDs - std::array(AiObjectType::Count)> mObjectNameMap; // Cache of encoded names - -public: - /// Stringstream to write all output into - std::stringstream mOutput; - - /// The IOSystem for output - IOSystem *mIOSystem; - - /// Path of the directory where the scene will be exported - const std::string mPath; - - /// Name of the file (without extension) where the scene will be exported - const std::string mFile; - - /// The scene to be written - const aiScene *const mScene; - std::string mSceneId; - bool mAdd_root_node = false; - - /// current line start string, contains the current indentation for simple stream insertion - std::string startstr; - /// current line end string for simple stream insertion - const std::string endstr; - - // pair of color and texture - texture precedences color - struct Surface { - bool exist; - aiColor4D color; - std::string texture; - size_t channel; - Surface() { - exist = false; - channel = 0; - } - }; - - struct Property { - bool exist; - ai_real value; - Property() : - exist(false), - value(0.0) {} - }; - - // summarize a material in an convenient way. - struct Material { - std::string id; - std::string name; - std::string shading_model; - Surface ambient, diffuse, specular, emissive, reflective, transparent, normal; - Property shininess, transparency, index_refraction; - - Material() {} - }; - - std::map textures; - -public: - /// Dammit C++ - y u no compile two-pass? No I have to add all methods below the struct definitions - /// Reads a single surface entry from the given material keys - bool ReadMaterialSurface(Surface &poSurface, const aiMaterial &pSrcMat, aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex); - /// Writes an image entry for the given surface - void WriteImageEntry(const Surface &pSurface, const std::string &imageId); - /// Writes the two parameters necessary for referencing a texture in an effect entry - void WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &materialId); - /// Writes a color-or-texture entry into an effect definition - void WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &imageId); - /// Writes a scalar property - void WriteFloatEntry(const Property &pProperty, const std::string &pTypeName); -}; - -} // namespace Assimp - -#endif // !! AI_COLLADAEXPORTER_H_INC diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp deleted file mode 100644 index 0fb172f..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.cpp +++ /dev/null @@ -1,99 +0,0 @@ -/* -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. - ----------------------------------------------------------------------- -*/ -/** Helper structures for the Collada loader */ - -#include "ColladaHelper.h" - -#include -#include - -namespace Assimp { -namespace Collada { - -const MetaKeyPairVector MakeColladaAssimpMetaKeys() { - MetaKeyPairVector result; - result.emplace_back("authoring_tool", AI_METADATA_SOURCE_GENERATOR); - result.emplace_back("copyright", AI_METADATA_SOURCE_COPYRIGHT); - return result; -} - -const MetaKeyPairVector &GetColladaAssimpMetaKeys() { - static const MetaKeyPairVector result = MakeColladaAssimpMetaKeys(); - return result; -} - -const MetaKeyPairVector MakeColladaAssimpMetaKeysCamelCase() { - MetaKeyPairVector result = MakeColladaAssimpMetaKeys(); - for (auto &val : result) { - ToCamelCase(val.first); - } - return result; -} - -const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase() { - static const MetaKeyPairVector result = MakeColladaAssimpMetaKeysCamelCase(); - return result; -} - -// ------------------------------------------------------------------------------------------------ -// Convert underscore_separated to CamelCase: "authoring_tool" becomes "AuthoringTool" -void ToCamelCase(std::string &text) { - if (text.empty()) - return; - // Capitalise first character - auto it = text.begin(); - (*it) = ai_toupper(*it); - ++it; - for (/*started above*/; it != text.end(); /*iterated below*/) { - if ((*it) == '_') { - it = text.erase(it); - if (it != text.end()) - (*it) = ai_toupper(*it); - } else { - // Make lower case - (*it) = ai_tolower(*it); - ++it; - } - } -} - -} // namespace Collada -} // namespace Assimp diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h deleted file mode 100644 index 31d7b5a..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaHelper.h +++ /dev/null @@ -1,679 +0,0 @@ -/* -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. - ----------------------------------------------------------------------- -*/ - -/** Helper structures for the Collada loader */ - -#ifndef AI_COLLADAHELPER_H_INC -#define AI_COLLADAHELPER_H_INC - -#include -#include -#include - -#include -#include -#include -#include - -struct aiMaterial; - -namespace Assimp { -namespace Collada { - -/// Collada file versions which evolved during the years ... -enum FormatVersion { - FV_1_5_n, - FV_1_4_n, - FV_1_3_n -}; - -/// Transformation types that can be applied to a node -enum TransformType { - TF_LOOKAT, - TF_ROTATE, - TF_TRANSLATE, - TF_SCALE, - TF_SKEW, - TF_MATRIX -}; - -/// Different types of input data to a vertex or face -enum InputType { - IT_Invalid, - IT_Vertex, // special type for per-index data referring to the element carrying the per-vertex data. - IT_Position, - IT_Normal, - IT_Texcoord, - IT_Color, - IT_Tangent, - IT_Bitangent -}; - -/// Supported controller types -enum ControllerType { - Skin, - Morph -}; - -/// Supported morph methods -enum MorphMethod { - Normalized, - Relative -}; - -/// Common metadata keys as -using MetaKeyPair = std::pair; -using MetaKeyPairVector = std::vector; - -/// Collada as lower_case (native) -const MetaKeyPairVector &GetColladaAssimpMetaKeys(); - -// Collada as CamelCase (used by Assimp for consistency) -const MetaKeyPairVector &GetColladaAssimpMetaKeysCamelCase(); - -/// Convert underscore_separated to CamelCase "authoring_tool" becomes "AuthoringTool" -void ToCamelCase(std::string &text); - -/// Contains all data for one of the different transformation types -struct Transform { - std::string mID; ///< SID of the transform step, by which anim channels address their target node - TransformType mType; - ai_real f[16]; ///< Interpretation of data depends on the type of the transformation -}; - -/// A collada camera. -struct Camera { - Camera() : - mOrtho(false), - mHorFov(10e10f), - mVerFov(10e10f), - mAspect(10e10f), - mZNear(0.1f), - mZFar(1000.f) {} - - /// Name of camera - std::string mName; - - /// True if it is an orthographic camera - bool mOrtho; - - /// Horizontal field of view in degrees - ai_real mHorFov; - - /// Vertical field of view in degrees - ai_real mVerFov; - - /// Screen aspect - ai_real mAspect; - - /// Near& far z - ai_real mZNear, mZFar; -}; - -#define ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET 1e9f - -/** A collada light source. */ -struct Light { - Light() : - mType(aiLightSource_UNDEFINED), - mAttConstant(1.f), - mAttLinear(0.f), - mAttQuadratic(0.f), - mFalloffAngle(180.f), - mFalloffExponent(0.f), - mPenumbraAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET), - mOuterAngle(ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET), - mIntensity(1.f) {} - - /// Type of the light source aiLightSourceType + ambient - unsigned int mType; - - /// Color of the light - aiColor3D mColor; - - /// Light attenuation - ai_real mAttConstant, mAttLinear, mAttQuadratic; - - /// Spot light falloff - ai_real mFalloffAngle; - ai_real mFalloffExponent; - - // ----------------------------------------------------- - // FCOLLADA extension from here - - /// ... related stuff from maja and max extensions - ai_real mPenumbraAngle; - ai_real mOuterAngle; - - /// Common light intensity - ai_real mIntensity; -}; - -/** Short vertex index description */ -struct InputSemanticMapEntry { - InputSemanticMapEntry() : - mSet(0), - mType(IT_Invalid) {} - - /// Index of set, optional - unsigned int mSet; - - /// Type of referenced vertex input - InputType mType; -}; - -/// Table to map from effect to vertex input semantics -struct SemanticMappingTable { - /// Name of material - std::string mMatName; - - /// List of semantic map commands, grouped by effect semantic name - using InputSemanticMap = std::map; - InputSemanticMap mMap; - - /// For std::find - bool operator==(const std::string &s) const { - return s == mMatName; - } -}; - -/// A reference to a mesh inside a node, including materials assigned to the various subgroups. -/// The ID refers to either a mesh or a controller which specifies the mesh -struct MeshInstance { - ///< ID of the mesh or controller to be instanced - std::string mMeshOrController; - - ///< Map of materials by the subgroup ID they're applied to - std::map mMaterials; -}; - -/// A reference to a camera inside a node -struct CameraInstance { - ///< ID of the camera - std::string mCamera; -}; - -/// A reference to a light inside a node -struct LightInstance { - ///< ID of the camera - std::string mLight; -}; - -/// A reference to a node inside a node -struct NodeInstance { - ///< ID of the node - std::string mNode; -}; - -/// A node in a scene hierarchy -struct Node { - std::string mName; - std::string mID; - std::string mSID; - Node *mParent; - std::vector mChildren; - - /// Operations in order to calculate the resulting transformation to parent. - std::vector mTransforms; - - /// Meshes at this node - std::vector mMeshes; - - /// Lights at this node - std::vector mLights; - - /// Cameras at this node - std::vector mCameras; - - /// Node instances at this node - std::vector mNodeInstances; - - /// Root-nodes: Name of primary camera, if any - std::string mPrimaryCamera; - - /// Constructor. Begin with a zero parent - Node() : - mParent(nullptr) { - // empty - } - - /// Destructor: delete all children subsequently - ~Node() { - for (std::vector::iterator it = mChildren.begin(); it != mChildren.end(); ++it) { - delete *it; - } - } -}; - -/// Data source array: either floats or strings -struct Data { - bool mIsStringArray; - std::vector mValues; - std::vector mStrings; -}; - -/// Accessor to a data array -struct Accessor { - size_t mCount; // in number of objects - size_t mSize; // size of an object, in elements (floats or strings, mostly 1) - size_t mOffset; // in number of values - size_t mStride; // Stride in number of values - std::vector mParams; // names of the data streams in the accessors. Empty string tells to ignore. - size_t mSubOffset[4]; // Sub-offset inside the object for the common 4 elements. For a vector, that's XYZ, for a color RGBA and so on. - // For example, SubOffset[0] denotes which of the values inside the object is the vector X component. - std::string mSource; // URL of the source array - mutable const Data *mData; // Pointer to the source array, if resolved. nullptr else - - Accessor() { - mCount = 0; - mSize = 0; - mOffset = 0; - mStride = 0; - mData = nullptr; - mSubOffset[0] = mSubOffset[1] = mSubOffset[2] = mSubOffset[3] = 0; - } -}; - -/// A single face in a mesh -struct Face { - std::vector mIndices; -}; - -/// An input channel for mesh data, referring to a single accessor -struct InputChannel { - InputType mType; // Type of the data - size_t mIndex; // Optional index, if multiple sets of the same data type are given - size_t mOffset; // Index offset in the indices array of per-face indices. Don't ask, can't explain that any better. - std::string mAccessor; // ID of the accessor where to read the actual values from. - mutable const Accessor *mResolved; // Pointer to the accessor, if resolved. nullptr else - - InputChannel() { - mType = IT_Invalid; - mIndex = 0; - mOffset = 0; - mResolved = nullptr; - } -}; - -/// Subset of a mesh with a certain material -struct SubMesh { - std::string mMaterial; ///< subgroup identifier - size_t mNumFaces; ///< number of faces in this sub-mesh -}; - -/// Contains data for a single mesh -struct Mesh { - Mesh(const std::string &id) : - mId(id) { - for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) { - mNumUVComponents[i] = 2; - } - } - - const std::string mId; - std::string mName; - - // just to check if there's some sophisticated addressing involved... - // which we don't support, and therefore should warn about. - std::string mVertexID; - - // Vertex data addressed by vertex indices - std::vector mPerVertexData; - - // actual mesh data, assembled on encounter of a

element. Verbose format, not indexed - std::vector mPositions; - std::vector mNormals; - std::vector mTangents; - std::vector mBitangents; - std::vector mTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - std::vector mColors[AI_MAX_NUMBER_OF_COLOR_SETS]; - - unsigned int mNumUVComponents[AI_MAX_NUMBER_OF_TEXTURECOORDS]; - - // Faces. Stored are only the number of vertices for each face. - // 1 == point, 2 == line, 3 == triangle, 4+ == poly - std::vector mFaceSize; - - // Position indices for all faces in the sequence given in mFaceSize - - // necessary for bone weight assignment - std::vector mFacePosIndices; - - // Sub-meshes in this mesh, each with a given material - std::vector mSubMeshes; -}; - -/// Which type of primitives the ReadPrimitives() function is going to read -enum PrimitiveType { - Prim_Invalid, - Prim_Lines, - Prim_LineStrip, - Prim_Triangles, - Prim_TriStrips, - Prim_TriFans, - Prim_Polylist, - Prim_Polygon -}; - -/// A skeleton controller to deform a mesh with the use of joints -struct Controller { - // controller type - ControllerType mType; - - // Morphing method if type is Morph - MorphMethod mMethod; - - // the URL of the mesh deformed by the controller. - std::string mMeshId; - - // accessor URL of the joint names - std::string mJointNameSource; - - ///< The bind shape matrix, as array of floats. I'm not sure what this matrix actually describes, but it can't be ignored in all cases - ai_real mBindShapeMatrix[16]; - - // accessor URL of the joint inverse bind matrices - std::string mJointOffsetMatrixSource; - - // input channel: joint names. - InputChannel mWeightInputJoints; - // input channel: joint weights - InputChannel mWeightInputWeights; - - // Number of weights per vertex. - std::vector mWeightCounts; - - // JointIndex-WeightIndex pairs for all vertices - std::vector> mWeights; - - std::string mMorphTarget; - std::string mMorphWeight; -}; - -/// A collada material. Pretty much the only member is a reference to an effect. -struct Material { - std::string mName; - std::string mEffect; -}; - -/// Type of the effect param -enum ParamType { - Param_Sampler, - Param_Surface -}; - -/// A param for an effect. Might be of several types, but they all just refer to each other, so I summarize them -struct EffectParam { - ParamType mType; - std::string mReference; // to which other thing the param is referring to. -}; - -/// Shading type supported by the standard effect spec of Collada -enum ShadeType { - Shade_Invalid, - Shade_Constant, - Shade_Lambert, - Shade_Phong, - Shade_Blinn -}; - -/// Represents a texture sampler in collada -struct Sampler { - Sampler() : - mWrapU(true), - mWrapV(true), - mMirrorU(), - mMirrorV(), - mOp(aiTextureOp_Multiply), - mUVId(UINT_MAX), - mWeighting(1.f), - mMixWithPrevious(1.f) {} - - /// Name of image reference - std::string mName; - - /// Wrap U? - bool mWrapU; - - /// Wrap V? - bool mWrapV; - - /// Mirror U? - bool mMirrorU; - - /// Mirror V? - bool mMirrorV; - - /// Blend mode - aiTextureOp mOp; - - /// UV transformation - aiUVTransform mTransform; - - /// Name of source UV channel - std::string mUVChannel; - - /// Resolved UV channel index or UINT_MAX if not known - unsigned int mUVId; - - // OKINO/MAX3D extensions from here - // ------------------------------------------------------- - - /// Weighting factor - ai_real mWeighting; - - /// Mixing factor from OKINO - ai_real mMixWithPrevious; -}; - -/// A collada effect. Can contain about anything according to the Collada spec, -/// but we limit our version to a reasonable subset. -struct Effect { - /// Shading mode - ShadeType mShadeType; - - /// Colors - aiColor4D mEmissive, mAmbient, mDiffuse, mSpecular, - mTransparent, mReflective; - - /// Textures - Sampler mTexEmissive, mTexAmbient, mTexDiffuse, mTexSpecular, - mTexTransparent, mTexBump, mTexReflective; - - /// Scalar factory - ai_real mShininess, mRefractIndex, mReflectivity; - ai_real mTransparency; - bool mHasTransparency; - bool mRGBTransparency; - bool mInvertTransparency; - - /// local params referring to each other by their SID - using ParamLibrary = std::map; - ParamLibrary mParams; - - // MAX3D extensions - // --------------------------------------------------------- - // Double-sided? - bool mDoubleSided, mWireframe, mFaceted; - - Effect() : - mShadeType(Shade_Phong), - mEmissive(0, 0, 0, 1), - mAmbient(0.1f, 0.1f, 0.1f, 1), - mDiffuse(0.6f, 0.6f, 0.6f, 1), - mSpecular(0.4f, 0.4f, 0.4f, 1), - mTransparent(0, 0, 0, 1), - mShininess(10.0f), - mRefractIndex(1.f), - mReflectivity(0.f), - mTransparency(1.f), - mHasTransparency(false), - mRGBTransparency(false), - mInvertTransparency(false), - mDoubleSided(false), - mWireframe(false), - mFaceted(false) { - } -}; - -/// An image, meaning texture -struct Image { - std::string mFileName; - - /// Embedded image data - std::vector mImageData; - - /// File format hint of embedded image data - std::string mEmbeddedFormat; -}; - -/// An animation channel. -struct AnimationChannel { - /// URL of the data to animate. Could be about anything, but we support only the - /// "NodeID/TransformID.SubElement" notation - std::string mTarget; - - /// Source URL of the time values. Collada calls them "input". Meh. - std::string mSourceTimes; - /// Source URL of the value values. Collada calls them "output". - std::string mSourceValues; - /// Source URL of the IN_TANGENT semantic values. - std::string mInTanValues; - /// Source URL of the OUT_TANGENT semantic values. - std::string mOutTanValues; - /// Source URL of the INTERPOLATION semantic values. - std::string mInterpolationValues; -}; - -/// An animation. Container for 0-x animation channels or 0-x animations -struct Animation { - /// Anim name - std::string mName; - - /// the animation channels, if any - std::vector mChannels; - - /// the sub-animations, if any - std::vector mSubAnims; - - /// Destructor - ~Animation() { - for (std::vector::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) { - delete *it; - } - } - - /// Collect all channels in the animation hierarchy into a single channel list. - void CollectChannelsRecursively(std::vector &channels) { - channels.insert(channels.end(), mChannels.begin(), mChannels.end()); - - for (std::vector::iterator it = mSubAnims.begin(); it != mSubAnims.end(); ++it) { - Animation *pAnim = (*it); - pAnim->CollectChannelsRecursively(channels); - } - } - - /// Combine all single-channel animations' channel into the same (parent) animation channel list. - void CombineSingleChannelAnimations() { - CombineSingleChannelAnimationsRecursively(this); - } - - void CombineSingleChannelAnimationsRecursively(Animation *pParent) { - std::set childrenTargets; - bool childrenAnimationsHaveDifferentChannels = true; - - for (std::vector::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) { - Animation *anim = *it; - CombineSingleChannelAnimationsRecursively(anim); - - if (childrenAnimationsHaveDifferentChannels && anim->mChannels.size() == 1 && - childrenTargets.find(anim->mChannels[0].mTarget) == childrenTargets.end()) { - childrenTargets.insert(anim->mChannels[0].mTarget); - } else { - childrenAnimationsHaveDifferentChannels = false; - } - - ++it; - } - - // We only want to combine animations if they have different channels - if (childrenAnimationsHaveDifferentChannels) { - for (std::vector::iterator it = pParent->mSubAnims.begin(); it != pParent->mSubAnims.end();) { - Animation *anim = *it; - - pParent->mChannels.push_back(anim->mChannels[0]); - - it = pParent->mSubAnims.erase(it); - - delete anim; - continue; - } - } - } -}; - -/// Description of a collada animation channel which has been determined to affect the current node -struct ChannelEntry { - const Collada::AnimationChannel *mChannel; ///< the source channel - std::string mTargetId; - std::string mTransformId; // the ID of the transformation step of the node which is influenced - size_t mTransformIndex; // Index into the node's transform chain to apply the channel to - size_t mSubElement; // starting index inside the transform data - - // resolved data references - const Collada::Accessor *mTimeAccessor; ///> Collada accessor to the time values - const Collada::Data *mTimeData; ///> Source data array for the time values - const Collada::Accessor *mValueAccessor; ///> Collada accessor to the key value values - const Collada::Data *mValueData; ///> Source datat array for the key value values - - ChannelEntry() : - mChannel(), - mTransformIndex(), - mSubElement(), - mTimeAccessor(), - mTimeData(), - mValueAccessor(), - mValueData() {} -}; - -} // end of namespace Collada -} // end of namespace Assimp - -#endif // AI_COLLADAHELPER_H_INC diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp deleted file mode 100644 index 775ba44..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.cpp +++ /dev/null @@ -1,1828 +0,0 @@ -/* ---------------------------------------------------------------------------- -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 Collada loader */ - -#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER - -#include "ColladaLoader.h" -#include "ColladaParser.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -namespace Assimp { - -using namespace Assimp::Formatter; -using namespace Assimp::Collada; - -static const aiImporterDesc desc = { - "Collada Importer", - "", - "", - "http://collada.org", - aiImporterFlags_SupportTextFlavour | aiImporterFlags_SupportCompressedFlavour, - 1, - 3, - 1, - 5, - "dae xml zae" -}; - -static const float kMillisecondsFromSeconds = 1000.f; - -// Add an item of metadata to a node -// Assumes the key is not already in the list -template -inline void AddNodeMetaData(aiNode *node, const std::string &key, const T &value) { - if (nullptr == node->mMetaData) { - node->mMetaData = new aiMetadata(); - } - node->mMetaData->Add(key, value); -} - -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -ColladaLoader::ColladaLoader() : - mFileName(), - mMeshIndexByID(), - mMaterialIndexByName(), - mMeshes(), - newMats(), - mCameras(), - mLights(), - mTextures(), - mAnims(), - noSkeletonMesh(false), - ignoreUpDirection(false), - useColladaName(false), - mNodeNameCounter(0) { - // empty -} - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -ColladaLoader::~ColladaLoader() { - // empty -} - -// ------------------------------------------------------------------------------------------------ -// Returns whether the class can handle the format of the given file. -bool ColladaLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const { - // Look for a DAE file inside, but don't extract it - ZipArchiveIOSystem zip_archive(pIOHandler, pFile); - if (zip_archive.isOpen()) { - return !ColladaParser::ReadZaeManifest(zip_archive).empty(); - } - - static const char *tokens[] = { "GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0; - ignoreUpDirection = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_IGNORE_UP_DIRECTION, 0) != 0; - useColladaName = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_COLLADA_USE_COLLADA_NAMES, 0) != 0; -} - -// ------------------------------------------------------------------------------------------------ -// Get file extension list -const aiImporterDesc *ColladaLoader::GetInfo() const { - return &desc; -} - -// ------------------------------------------------------------------------------------------------ -// Imports the given file into the given scene structure. -void ColladaLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) { - mFileName = pFile; - - // clean all member arrays - just for safety, it should work even if we did not - mMeshIndexByID.clear(); - mMaterialIndexByName.clear(); - mMeshes.clear(); - mTargetMeshes.clear(); - newMats.clear(); - mLights.clear(); - mCameras.clear(); - mTextures.clear(); - mAnims.clear(); - - // parse the input file - ColladaParser parser(pIOHandler, pFile); - - if (!parser.mRootNode) { - throw DeadlyImportError("Collada: File came out empty. Something is wrong here."); - } - - // reserve some storage to avoid unnecessary reallocs - newMats.reserve(parser.mMaterialLibrary.size() * 2u); - mMeshes.reserve(parser.mMeshLibrary.size() * 2u); - - mCameras.reserve(parser.mCameraLibrary.size()); - mLights.reserve(parser.mLightLibrary.size()); - - // create the materials first, for the meshes to find - BuildMaterials(parser, pScene); - - // build the node hierarchy from it - pScene->mRootNode = BuildHierarchy(parser, parser.mRootNode); - - // ... then fill the materials with the now adjusted settings - FillMaterials(parser, pScene); - - // Apply unit-size scale calculation - - pScene->mRootNode->mTransformation *= aiMatrix4x4(parser.mUnitSize, 0, 0, 0, - 0, parser.mUnitSize, 0, 0, - 0, 0, parser.mUnitSize, 0, - 0, 0, 0, 1); - if (!ignoreUpDirection) { - // Convert to Y_UP, if different orientation - if (parser.mUpDirection == ColladaParser::UP_X) { - pScene->mRootNode->mTransformation *= aiMatrix4x4( - 0, -1, 0, 0, - 1, 0, 0, 0, - 0, 0, 1, 0, - 0, 0, 0, 1); - } else if (parser.mUpDirection == ColladaParser::UP_Z) { - pScene->mRootNode->mTransformation *= aiMatrix4x4( - 1, 0, 0, 0, - 0, 0, 1, 0, - 0, -1, 0, 0, - 0, 0, 0, 1); - } - } - - // Store scene metadata - if (!parser.mAssetMetaData.empty()) { - const size_t numMeta(parser.mAssetMetaData.size()); - pScene->mMetaData = aiMetadata::Alloc(static_cast(numMeta)); - size_t i = 0; - for (auto it = parser.mAssetMetaData.cbegin(); it != parser.mAssetMetaData.cend(); ++it, ++i) { - pScene->mMetaData->Set(static_cast(i), (*it).first, (*it).second); - } - } - - StoreSceneMeshes(pScene); - StoreSceneMaterials(pScene); - StoreSceneTextures(pScene); - StoreSceneLights(pScene); - StoreSceneCameras(pScene); - StoreAnimations(pScene, parser); - - // If no meshes have been loaded, it's probably just an animated skeleton. - if (0u == pScene->mNumMeshes) { - if (!noSkeletonMesh) { - SkeletonMeshBuilder hero(pScene); - } - pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; - } -} - -// ------------------------------------------------------------------------------------------------ -// Recursively constructs a scene node for the given parser node and returns it. -aiNode *ColladaLoader::BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode) { - // create a node for it - aiNode *node = new aiNode(); - - // find a name for the new node. It's more complicated than you might think - node->mName.Set(FindNameForNode(pNode)); - // if we're not using the unique IDs, hold onto them for reference and export - if (useColladaName) { - if (!pNode->mID.empty()) { - AddNodeMetaData(node, AI_METADATA_COLLADA_ID, aiString(pNode->mID)); - } - if (!pNode->mSID.empty()) { - AddNodeMetaData(node, AI_METADATA_COLLADA_SID, aiString(pNode->mSID)); - } - } - - // calculate the transformation matrix for it - node->mTransformation = pParser.CalculateResultTransform(pNode->mTransforms); - - // now resolve node instances - std::vector instances; - ResolveNodeInstances(pParser, pNode, instances); - - // add children. first the *real* ones - node->mNumChildren = static_cast(pNode->mChildren.size() + instances.size()); - node->mChildren = new aiNode *[node->mNumChildren]; - - for (size_t a = 0; a < pNode->mChildren.size(); ++a) { - node->mChildren[a] = BuildHierarchy(pParser, pNode->mChildren[a]); - node->mChildren[a]->mParent = node; - } - - // ... and finally the resolved node instances - for (size_t a = 0; a < instances.size(); ++a) { - node->mChildren[pNode->mChildren.size() + a] = BuildHierarchy(pParser, instances[a]); - node->mChildren[pNode->mChildren.size() + a]->mParent = node; - } - - BuildMeshesForNode(pParser, pNode, node); - BuildCamerasForNode(pParser, pNode, node); - BuildLightsForNode(pParser, pNode, node); - - return node; -} - -// ------------------------------------------------------------------------------------------------ -// Resolve node instances -void ColladaLoader::ResolveNodeInstances(const ColladaParser &pParser, const Node *pNode, - std::vector &resolved) { - // reserve enough storage - resolved.reserve(pNode->mNodeInstances.size()); - - // ... and iterate through all nodes to be instanced as children of pNode - for (const auto &nodeInst : pNode->mNodeInstances) { - // find the corresponding node in the library - const ColladaParser::NodeLibrary::const_iterator itt = pParser.mNodeLibrary.find(nodeInst.mNode); - const Node *nd = itt == pParser.mNodeLibrary.end() ? nullptr : (*itt).second; - - // FIX for http://sourceforge.net/tracker/?func=detail&aid=3054873&group_id=226462&atid=1067632 - // need to check for both name and ID to catch all. To avoid breaking valid files, - // the workaround is only enabled when the first attempt to resolve the node has failed. - if (nullptr == nd) { - nd = FindNode(pParser.mRootNode, nodeInst.mNode); - } - if (nullptr == nd) { - ASSIMP_LOG_ERROR("Collada: Unable to resolve reference to instanced node ", nodeInst.mNode); - } else { - // attach this node to the list of children - resolved.push_back(nd); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Resolve UV channels -void ColladaLoader::ApplyVertexToEffectSemanticMapping(Sampler &sampler, const SemanticMappingTable &table) { - SemanticMappingTable::InputSemanticMap::const_iterator it = table.mMap.find(sampler.mUVChannel); - if (it == table.mMap.end()) { - return; - } - - if (it->second.mType != IT_Texcoord) { - ASSIMP_LOG_ERROR("Collada: Unexpected effect input mapping"); - } - - sampler.mUVId = it->second.mSet; -} - -// ------------------------------------------------------------------------------------------------ -// Builds lights for the given node and references them -void ColladaLoader::BuildLightsForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) { - for (const LightInstance &lid : pNode->mLights) { - // find the referred light - ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find(lid.mLight); - if (srcLightIt == pParser.mLightLibrary.end()) { - ASSIMP_LOG_WARN("Collada: Unable to find light for ID \"", lid.mLight, "\". Skipping."); - continue; - } - const Collada::Light *srcLight = &srcLightIt->second; - - // now fill our ai data structure - aiLight *out = new aiLight(); - out->mName = pTarget->mName; - out->mType = (aiLightSourceType)srcLight->mType; - - // collada lights point in -Z by default, rest is specified in node transform - out->mDirection = aiVector3D(0.f, 0.f, -1.f); - - out->mAttenuationConstant = srcLight->mAttConstant; - out->mAttenuationLinear = srcLight->mAttLinear; - out->mAttenuationQuadratic = srcLight->mAttQuadratic; - - out->mColorDiffuse = out->mColorSpecular = out->mColorAmbient = srcLight->mColor * srcLight->mIntensity; - if (out->mType == aiLightSource_AMBIENT) { - out->mColorDiffuse = out->mColorSpecular = aiColor3D(0, 0, 0); - out->mColorAmbient = srcLight->mColor * srcLight->mIntensity; - } else { - // collada doesn't differentiate between these color types - out->mColorDiffuse = out->mColorSpecular = srcLight->mColor * srcLight->mIntensity; - out->mColorAmbient = aiColor3D(0, 0, 0); - } - - // convert falloff angle and falloff exponent in our representation, if given - if (out->mType == aiLightSource_SPOT) { - out->mAngleInnerCone = AI_DEG_TO_RAD(srcLight->mFalloffAngle); - - // ... some extension magic. - if (srcLight->mOuterAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) { - // ... some deprecation magic. - if (srcLight->mPenumbraAngle >= ASSIMP_COLLADA_LIGHT_ANGLE_NOT_SET * (1 - ai_epsilon)) { - // Need to rely on falloff_exponent. I don't know how to interpret it, so I need to guess .... - // epsilon chosen to be 0.1 - float f = 1.0f; - if ( 0.0f != srcLight->mFalloffExponent ) { - f = 1.f / srcLight->mFalloffExponent; - } - out->mAngleOuterCone = std::acos(std::pow(0.1f, f)) + - out->mAngleInnerCone; - } else { - out->mAngleOuterCone = out->mAngleInnerCone + AI_DEG_TO_RAD(srcLight->mPenumbraAngle); - if (out->mAngleOuterCone < out->mAngleInnerCone) - std::swap(out->mAngleInnerCone, out->mAngleOuterCone); - } - } else { - out->mAngleOuterCone = AI_DEG_TO_RAD(srcLight->mOuterAngle); - } - } - - // add to light list - mLights.push_back(out); - } -} - -// ------------------------------------------------------------------------------------------------ -// Builds cameras for the given node and references them -void ColladaLoader::BuildCamerasForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) { - for (const CameraInstance &cid : pNode->mCameras) { - // find the referred light - ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find(cid.mCamera); - if (srcCameraIt == pParser.mCameraLibrary.end()) { - ASSIMP_LOG_WARN("Collada: Unable to find camera for ID \"", cid.mCamera, "\". Skipping."); - continue; - } - const Collada::Camera *srcCamera = &srcCameraIt->second; - - // orthographic cameras not yet supported in Assimp - if (srcCamera->mOrtho) { - ASSIMP_LOG_WARN("Collada: Orthographic cameras are not supported."); - } - - // now fill our ai data structure - aiCamera *out = new aiCamera(); - out->mName = pTarget->mName; - - // collada cameras point in -Z by default, rest is specified in node transform - out->mLookAt = aiVector3D(0.f, 0.f, -1.f); - - // near/far z is already ok - out->mClipPlaneFar = srcCamera->mZFar; - out->mClipPlaneNear = srcCamera->mZNear; - - // ... but for the rest some values are optional - // and we need to compute the others in any combination. - if (srcCamera->mAspect != 10e10f) { - out->mAspect = srcCamera->mAspect; - } - - if (srcCamera->mHorFov != 10e10f) { - out->mHorizontalFOV = srcCamera->mHorFov; - - if (srcCamera->mVerFov != 10e10f && srcCamera->mAspect == 10e10f) { - out->mAspect = std::tan(AI_DEG_TO_RAD(srcCamera->mHorFov)) / - std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov)); - } - - } else if (srcCamera->mAspect != 10e10f && srcCamera->mVerFov != 10e10f) { - out->mHorizontalFOV = 2.0f * AI_RAD_TO_DEG(std::atan(srcCamera->mAspect * - std::tan(AI_DEG_TO_RAD(srcCamera->mVerFov) * 0.5f))); - } - - // Collada uses degrees, we use radians - out->mHorizontalFOV = AI_DEG_TO_RAD(out->mHorizontalFOV); - - // add to camera list - mCameras.push_back(out); - } -} - -// ------------------------------------------------------------------------------------------------ -// Builds meshes for the given node and references them -void ColladaLoader::BuildMeshesForNode(const ColladaParser &pParser, const Node *pNode, aiNode *pTarget) { - // accumulated mesh references by this node - std::vector newMeshRefs; - newMeshRefs.reserve(pNode->mMeshes.size()); - - // add a mesh for each subgroup in each collada mesh - for (const MeshInstance &mid : pNode->mMeshes) { - const Mesh *srcMesh = nullptr; - const Controller *srcController = nullptr; - - // find the referred mesh - ColladaParser::MeshLibrary::const_iterator srcMeshIt = pParser.mMeshLibrary.find(mid.mMeshOrController); - if (srcMeshIt == pParser.mMeshLibrary.end()) { - // if not found in the mesh-library, it might also be a controller referring to a mesh - ColladaParser::ControllerLibrary::const_iterator srcContrIt = pParser.mControllerLibrary.find(mid.mMeshOrController); - if (srcContrIt != pParser.mControllerLibrary.end()) { - srcController = &srcContrIt->second; - srcMeshIt = pParser.mMeshLibrary.find(srcController->mMeshId); - if (srcMeshIt != pParser.mMeshLibrary.end()) { - srcMesh = srcMeshIt->second; - } - } - - if (nullptr == srcMesh) { - ASSIMP_LOG_WARN("Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping."); - continue; - } - } else { - // ID found in the mesh library -> direct reference to an unskinned mesh - srcMesh = srcMeshIt->second; - } - - // build a mesh for each of its subgroups - size_t vertexStart = 0, faceStart = 0; - for (size_t sm = 0; sm < srcMesh->mSubMeshes.size(); ++sm) { - const Collada::SubMesh &submesh = srcMesh->mSubMeshes[sm]; - if (submesh.mNumFaces == 0) { - continue; - } - - // find material assigned to this submesh - std::string meshMaterial; - std::map::const_iterator meshMatIt = mid.mMaterials.find(submesh.mMaterial); - - const Collada::SemanticMappingTable *table = nullptr; - if (meshMatIt != mid.mMaterials.end()) { - table = &meshMatIt->second; - meshMaterial = table->mMatName; - } else { - ASSIMP_LOG_WARN("Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <", - mid.mMeshOrController, ">."); - if (!mid.mMaterials.empty()) { - meshMaterial = mid.mMaterials.begin()->second.mMatName; - } - } - - // OK ... here the *real* fun starts ... we have the vertex-input-to-effect-semantic-table - // given. The only mapping stuff which we do actually support is the UV channel. - std::map::const_iterator matIt = mMaterialIndexByName.find(meshMaterial); - unsigned int matIdx = 0; - if (matIt != mMaterialIndexByName.end()) { - matIdx = static_cast(matIt->second); - } - - if (table && !table->mMap.empty()) { - std::pair &mat = newMats[matIdx]; - - // Iterate through all texture channels assigned to the effect and - // check whether we have mapping information for it. - ApplyVertexToEffectSemanticMapping(mat.first->mTexDiffuse, *table); - ApplyVertexToEffectSemanticMapping(mat.first->mTexAmbient, *table); - ApplyVertexToEffectSemanticMapping(mat.first->mTexSpecular, *table); - ApplyVertexToEffectSemanticMapping(mat.first->mTexEmissive, *table); - ApplyVertexToEffectSemanticMapping(mat.first->mTexTransparent, *table); - ApplyVertexToEffectSemanticMapping(mat.first->mTexBump, *table); - } - - // built lookup index of the Mesh-Submesh-Material combination - ColladaMeshIndex index(mid.mMeshOrController, sm, meshMaterial); - - // if we already have the mesh at the library, just add its index to the node's array - std::map::const_iterator dstMeshIt = mMeshIndexByID.find(index); - if (dstMeshIt != mMeshIndexByID.end()) { - newMeshRefs.push_back(dstMeshIt->second); - } else { - // else we have to add the mesh to the collection and store its newly assigned index at the node - aiMesh *dstMesh = CreateMesh(pParser, srcMesh, submesh, srcController, vertexStart, faceStart); - - // store the mesh, and store its new index in the node - newMeshRefs.push_back(mMeshes.size()); - mMeshIndexByID[index] = mMeshes.size(); - mMeshes.push_back(dstMesh); - vertexStart += dstMesh->mNumVertices; - faceStart += submesh.mNumFaces; - - // assign the material index - std::map::const_iterator subMatIt = mMaterialIndexByName.find(submesh.mMaterial); - if (subMatIt != mMaterialIndexByName.end()) { - dstMesh->mMaterialIndex = static_cast(subMatIt->second); - } else { - dstMesh->mMaterialIndex = matIdx; - } - if (dstMesh->mName.length == 0) { - dstMesh->mName = mid.mMeshOrController; - } - } - } - } - - // now place all mesh references we gathered in the target node - pTarget->mNumMeshes = static_cast(newMeshRefs.size()); - if (!newMeshRefs.empty()) { - struct UIntTypeConverter { - unsigned int operator()(const size_t &v) const { - return static_cast(v); - } - }; - - pTarget->mMeshes = new unsigned int[pTarget->mNumMeshes]; - std::transform(newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes, UIntTypeConverter()); - } -} - -// ------------------------------------------------------------------------------------------------ -// Find mesh from either meshes or morph target meshes -aiMesh *ColladaLoader::findMesh(const std::string &meshid) { - if (meshid.empty()) { - return nullptr; - } - - for (auto & mMeshe : mMeshes) { - if (std::string(mMeshe->mName.data) == meshid) { - return mMeshe; - } - } - - for (auto & mTargetMeshe : mTargetMeshes) { - if (std::string(mTargetMeshe->mName.data) == meshid) { - return mTargetMeshe; - } - } - - return nullptr; -} - -// ------------------------------------------------------------------------------------------------ -// Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh -aiMesh *ColladaLoader::CreateMesh(const ColladaParser &pParser, const Mesh *pSrcMesh, const SubMesh &pSubMesh, - const Controller *pSrcController, size_t pStartVertex, size_t pStartFace) { - std::unique_ptr dstMesh(new aiMesh); - - if (useColladaName) { - dstMesh->mName = pSrcMesh->mName; - } else { - dstMesh->mName = pSrcMesh->mId; - } - - if (pSrcMesh->mPositions.empty()) { - return dstMesh.release(); - } - - // count the vertices addressed by its faces - const size_t numVertices = std::accumulate(pSrcMesh->mFaceSize.begin() + pStartFace, - pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0)); - - // copy positions - dstMesh->mNumVertices = static_cast(numVertices); - dstMesh->mVertices = new aiVector3D[numVertices]; - std::copy(pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() + pStartVertex + numVertices, dstMesh->mVertices); - - // normals, if given. HACK: (thom) Due to the glorious Collada spec we never - // know if we have the same number of normals as there are positions. So we - // also ignore any vertex attribute if it has a different count - if (pSrcMesh->mNormals.size() >= pStartVertex + numVertices) { - dstMesh->mNormals = new aiVector3D[numVertices]; - std::copy(pSrcMesh->mNormals.begin() + pStartVertex, pSrcMesh->mNormals.begin() + pStartVertex + numVertices, dstMesh->mNormals); - } - - // tangents, if given. - if (pSrcMesh->mTangents.size() >= pStartVertex + numVertices) { - dstMesh->mTangents = new aiVector3D[numVertices]; - std::copy(pSrcMesh->mTangents.begin() + pStartVertex, pSrcMesh->mTangents.begin() + pStartVertex + numVertices, dstMesh->mTangents); - } - - // bitangents, if given. - if (pSrcMesh->mBitangents.size() >= pStartVertex + numVertices) { - dstMesh->mBitangents = new aiVector3D[numVertices]; - std::copy(pSrcMesh->mBitangents.begin() + pStartVertex, pSrcMesh->mBitangents.begin() + pStartVertex + numVertices, dstMesh->mBitangents); - } - - // same for texture coords, as many as we have - // empty slots are not allowed, need to pack and adjust UV indexes accordingly - for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) { - if (pSrcMesh->mTexCoords[a].size() >= pStartVertex + numVertices) { - dstMesh->mTextureCoords[real] = new aiVector3D[numVertices]; - for (size_t b = 0; b < numVertices; ++b) { - dstMesh->mTextureCoords[real][b] = pSrcMesh->mTexCoords[a][pStartVertex + b]; - } - - dstMesh->mNumUVComponents[real] = pSrcMesh->mNumUVComponents[a]; - ++real; - } - } - - // same for vertex colors, as many as we have. again the same packing to avoid empty slots - for (size_t a = 0, real = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) { - if (pSrcMesh->mColors[a].size() >= pStartVertex + numVertices) { - dstMesh->mColors[real] = new aiColor4D[numVertices]; - std::copy(pSrcMesh->mColors[a].begin() + pStartVertex, pSrcMesh->mColors[a].begin() + pStartVertex + numVertices, dstMesh->mColors[real]); - ++real; - } - } - - // create faces. Due to the fact that each face uses unique vertices, we can simply count up on each vertex - size_t vertex = 0; - dstMesh->mNumFaces = static_cast(pSubMesh.mNumFaces); - dstMesh->mFaces = new aiFace[dstMesh->mNumFaces]; - for (size_t a = 0; a < dstMesh->mNumFaces; ++a) { - size_t s = pSrcMesh->mFaceSize[pStartFace + a]; - aiFace &face = dstMesh->mFaces[a]; - face.mNumIndices = static_cast(s); - face.mIndices = new unsigned int[s]; - for (size_t b = 0; b < s; ++b) { - face.mIndices[b] = static_cast(vertex++); - } - } - - // create morph target meshes if any - std::vector targetMeshes; - std::vector targetWeights; - Collada::MorphMethod method = Normalized; - - for (std::map::const_iterator it = pParser.mControllerLibrary.begin(); - it != pParser.mControllerLibrary.end(); ++it) { - const Controller &c = it->second; - const Collada::Mesh *baseMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, c.mMeshId); - - if (c.mType == Collada::Morph && baseMesh->mName == pSrcMesh->mName) { - const Collada::Accessor &targetAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphTarget); - const Collada::Accessor &weightAccessor = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, c.mMorphWeight); - const Collada::Data &targetData = pParser.ResolveLibraryReference(pParser.mDataLibrary, targetAccessor.mSource); - const Collada::Data &weightData = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightAccessor.mSource); - - // take method - method = c.mMethod; - - if (!targetData.mIsStringArray) { - throw DeadlyImportError("target data must contain id. "); - } - if (weightData.mIsStringArray) { - throw DeadlyImportError("target weight data must not be textual "); - } - - for (const auto & mString : targetData.mStrings) { - const Mesh *targetMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, mString); - - aiMesh *aimesh = findMesh(useColladaName ? targetMesh->mName : targetMesh->mId); - if (!aimesh) { - if (targetMesh->mSubMeshes.size() > 1) { - throw DeadlyImportError("Morphing target mesh must be a single"); - } - aimesh = CreateMesh(pParser, targetMesh, targetMesh->mSubMeshes.at(0), nullptr, 0, 0); - mTargetMeshes.push_back(aimesh); - } - targetMeshes.push_back(aimesh); - } - for (float mValue : weightData.mValues) { - targetWeights.push_back(mValue); - } - } - } - if (!targetMeshes.empty() && targetWeights.size() == targetMeshes.size()) { - std::vector animMeshes; - for (unsigned int i = 0; i < targetMeshes.size(); ++i) { - aiMesh *targetMesh = targetMeshes.at(i); - aiAnimMesh *animMesh = aiCreateAnimMesh(targetMesh); - float weight = targetWeights[i]; - animMesh->mWeight = weight == 0 ? 1.0f : weight; - animMesh->mName = targetMesh->mName; - animMeshes.push_back(animMesh); - } - dstMesh->mMethod = (method == Relative) ? aiMorphingMethod_MORPH_RELATIVE : aiMorphingMethod_MORPH_NORMALIZED; - dstMesh->mAnimMeshes = new aiAnimMesh *[animMeshes.size()]; - dstMesh->mNumAnimMeshes = static_cast(animMeshes.size()); - for (unsigned int i = 0; i < animMeshes.size(); ++i) { - dstMesh->mAnimMeshes[i] = animMeshes.at(i); - } - } - - // create bones if given - if (pSrcController && pSrcController->mType == Collada::Skin) { - // resolve references - joint names - const Collada::Accessor &jointNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointNameSource); - const Collada::Data &jointNames = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointNamesAcc.mSource); - // joint offset matrices - const Collada::Accessor &jointMatrixAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mJointOffsetMatrixSource); - const Collada::Data &jointMatrices = pParser.ResolveLibraryReference(pParser.mDataLibrary, jointMatrixAcc.mSource); - // joint vertex_weight name list - should refer to the same list as the joint names above. If not, report and reconsider - const Collada::Accessor &weightNamesAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor); - if (&weightNamesAcc != &jointNamesAcc) - throw DeadlyImportError("Temporary implementational laziness. If you read this, please report to the author."); - // vertex weights - const Collada::Accessor &weightsAcc = pParser.ResolveLibraryReference(pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor); - const Collada::Data &weights = pParser.ResolveLibraryReference(pParser.mDataLibrary, weightsAcc.mSource); - - if (!jointNames.mIsStringArray || jointMatrices.mIsStringArray || weights.mIsStringArray) { - throw DeadlyImportError("Data type mismatch while resolving mesh joints"); - } - // sanity check: we rely on the vertex weights always coming as pairs of BoneIndex-WeightIndex - if (pSrcController->mWeightInputJoints.mOffset != 0 || pSrcController->mWeightInputWeights.mOffset != 1) { - throw DeadlyImportError("Unsupported vertex_weight addressing scheme. "); - } - - // create containers to collect the weights for each bone - size_t numBones = jointNames.mStrings.size(); - std::vector> dstBones(numBones); - - // build a temporary array of pointers to the start of each vertex's weights - using IndexPairVector = std::vector>; - std::vector weightStartPerVertex; - weightStartPerVertex.resize(pSrcController->mWeightCounts.size(), pSrcController->mWeights.end()); - - IndexPairVector::const_iterator pit = pSrcController->mWeights.begin(); - for (size_t a = 0; a < pSrcController->mWeightCounts.size(); ++a) { - weightStartPerVertex[a] = pit; - pit += pSrcController->mWeightCounts[a]; - } - - // now for each vertex put the corresponding vertex weights into each bone's weight collection - for (size_t a = pStartVertex; a < pStartVertex + numVertices; ++a) { - // which position index was responsible for this vertex? that's also the index by which - // the controller assigns the vertex weights - size_t orgIndex = pSrcMesh->mFacePosIndices[a]; - // find the vertex weights for this vertex - IndexPairVector::const_iterator iit = weightStartPerVertex[orgIndex]; - size_t pairCount = pSrcController->mWeightCounts[orgIndex]; - - for (size_t b = 0; b < pairCount; ++b, ++iit) { - const size_t jointIndex = iit->first; - const size_t vertexIndex = iit->second; - ai_real weight = 1.0f; - if (!weights.mValues.empty()) { - weight = ReadFloat(weightsAcc, weights, vertexIndex, 0); - } - - // one day I gonna kill that XSI Collada exporter - if (weight > 0.0f) { - aiVertexWeight w; - w.mVertexId = static_cast(a - pStartVertex); - w.mWeight = weight; - dstBones[jointIndex].push_back(w); - } - } - } - - // count the number of bones which influence vertices of the current submesh - size_t numRemainingBones = 0; - for (const auto & dstBone : dstBones) { - if (!dstBone.empty()) { - ++numRemainingBones; - } - } - - // create bone array and copy bone weights one by one - dstMesh->mNumBones = static_cast(numRemainingBones); - dstMesh->mBones = new aiBone *[numRemainingBones]; - size_t boneCount = 0; - for (size_t a = 0; a < numBones; ++a) { - // omit bones without weights - if (dstBones[a].empty()) { - continue; - } - - // create bone with its weights - aiBone *bone = new aiBone; - bone->mName = ReadString(jointNamesAcc, jointNames, a); - bone->mOffsetMatrix.a1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 0); - bone->mOffsetMatrix.a2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 1); - bone->mOffsetMatrix.a3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 2); - bone->mOffsetMatrix.a4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 3); - bone->mOffsetMatrix.b1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 4); - bone->mOffsetMatrix.b2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 5); - bone->mOffsetMatrix.b3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 6); - bone->mOffsetMatrix.b4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 7); - bone->mOffsetMatrix.c1 = ReadFloat(jointMatrixAcc, jointMatrices, a, 8); - bone->mOffsetMatrix.c2 = ReadFloat(jointMatrixAcc, jointMatrices, a, 9); - bone->mOffsetMatrix.c3 = ReadFloat(jointMatrixAcc, jointMatrices, a, 10); - bone->mOffsetMatrix.c4 = ReadFloat(jointMatrixAcc, jointMatrices, a, 11); - bone->mNumWeights = static_cast(dstBones[a].size()); - bone->mWeights = new aiVertexWeight[bone->mNumWeights]; - std::copy(dstBones[a].begin(), dstBones[a].end(), bone->mWeights); - - // apply bind shape matrix to offset matrix - aiMatrix4x4 bindShapeMatrix; - bindShapeMatrix.a1 = pSrcController->mBindShapeMatrix[0]; - bindShapeMatrix.a2 = pSrcController->mBindShapeMatrix[1]; - bindShapeMatrix.a3 = pSrcController->mBindShapeMatrix[2]; - bindShapeMatrix.a4 = pSrcController->mBindShapeMatrix[3]; - bindShapeMatrix.b1 = pSrcController->mBindShapeMatrix[4]; - bindShapeMatrix.b2 = pSrcController->mBindShapeMatrix[5]; - bindShapeMatrix.b3 = pSrcController->mBindShapeMatrix[6]; - bindShapeMatrix.b4 = pSrcController->mBindShapeMatrix[7]; - bindShapeMatrix.c1 = pSrcController->mBindShapeMatrix[8]; - bindShapeMatrix.c2 = pSrcController->mBindShapeMatrix[9]; - bindShapeMatrix.c3 = pSrcController->mBindShapeMatrix[10]; - bindShapeMatrix.c4 = pSrcController->mBindShapeMatrix[11]; - bindShapeMatrix.d1 = pSrcController->mBindShapeMatrix[12]; - bindShapeMatrix.d2 = pSrcController->mBindShapeMatrix[13]; - bindShapeMatrix.d3 = pSrcController->mBindShapeMatrix[14]; - bindShapeMatrix.d4 = pSrcController->mBindShapeMatrix[15]; - bone->mOffsetMatrix *= bindShapeMatrix; - - // HACK: (thom) Some exporters address the bone nodes by SID, others address them by ID or even name. - // Therefore I added a little name replacement here: I search for the bone's node by either name, ID or SID, - // and replace the bone's name by the node's name so that the user can use the standard - // find-by-name method to associate nodes with bones. - const Collada::Node *bnode = FindNode(pParser.mRootNode, bone->mName.data); - if (nullptr == bnode) { - bnode = FindNodeBySID(pParser.mRootNode, bone->mName.data); - } - - // assign the name that we would have assigned for the source node - if (nullptr != bnode) { - bone->mName.Set(FindNameForNode(bnode)); - } else { - ASSIMP_LOG_WARN("ColladaLoader::CreateMesh(): could not find corresponding node for joint \"", bone->mName.data, "\"."); - } - - // and insert bone - dstMesh->mBones[boneCount++] = bone; - } - } - - return dstMesh.release(); -} - -// ------------------------------------------------------------------------------------------------ -// Stores all meshes in the given scene -void ColladaLoader::StoreSceneMeshes(aiScene *pScene) { - pScene->mNumMeshes = static_cast(mMeshes.size()); - if (mMeshes.empty()) { - return; - } - pScene->mMeshes = new aiMesh *[mMeshes.size()]; - std::copy(mMeshes.begin(), mMeshes.end(), pScene->mMeshes); - mMeshes.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Stores all cameras in the given scene -void ColladaLoader::StoreSceneCameras(aiScene *pScene) { - pScene->mNumCameras = static_cast(mCameras.size()); - if (mCameras.empty()) { - return; - } - pScene->mCameras = new aiCamera *[mCameras.size()]; - std::copy(mCameras.begin(), mCameras.end(), pScene->mCameras); - mCameras.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Stores all lights in the given scene -void ColladaLoader::StoreSceneLights(aiScene *pScene) { - pScene->mNumLights = static_cast(mLights.size()); - if (mLights.empty()) { - return; - } - pScene->mLights = new aiLight *[mLights.size()]; - std::copy(mLights.begin(), mLights.end(), pScene->mLights); - mLights.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Stores all textures in the given scene -void ColladaLoader::StoreSceneTextures(aiScene *pScene) { - pScene->mNumTextures = static_cast(mTextures.size()); - if (mTextures.empty()) { - return; - } - pScene->mTextures = new aiTexture *[mTextures.size()]; - std::copy(mTextures.begin(), mTextures.end(), pScene->mTextures); - mTextures.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Stores all materials in the given scene -void ColladaLoader::StoreSceneMaterials(aiScene *pScene) { - pScene->mNumMaterials = static_cast(newMats.size()); - if (newMats.empty()) { - return; - } - pScene->mMaterials = new aiMaterial *[newMats.size()]; - for (unsigned int i = 0; i < newMats.size(); ++i) { - pScene->mMaterials[i] = newMats[i].second; - } - newMats.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Stores all animations -void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser) { - // recursively collect all animations from the collada scene - StoreAnimations(pScene, pParser, &pParser.mAnims, ""); - - // catch special case: many animations with the same length, each affecting only a single node. - // we need to unite all those single-node-anims to a proper combined animation - for (size_t a = 0; a < mAnims.size(); ++a) { - aiAnimation *templateAnim = mAnims[a]; - - if (templateAnim->mNumChannels == 1) { - // search for other single-channel-anims with the same duration - std::vector collectedAnimIndices; - for (size_t b = a + 1; b < mAnims.size(); ++b) { - aiAnimation *other = mAnims[b]; - if (other->mNumChannels == 1 && other->mDuration == templateAnim->mDuration && - other->mTicksPerSecond == templateAnim->mTicksPerSecond) - collectedAnimIndices.push_back(b); - } - - // We only want to combine the animations if they have different channels - std::set animTargets; - animTargets.insert(templateAnim->mChannels[0]->mNodeName.C_Str()); - bool collectedAnimationsHaveDifferentChannels = true; - for (unsigned long long collectedAnimIndice : collectedAnimIndices) { - aiAnimation *srcAnimation = mAnims[(int)collectedAnimIndice]; - std::string channelName = std::string(srcAnimation->mChannels[0]->mNodeName.C_Str()); - if (animTargets.find(channelName) == animTargets.end()) { - animTargets.insert(channelName); - } else { - collectedAnimationsHaveDifferentChannels = false; - break; - } - } - - if (!collectedAnimationsHaveDifferentChannels) { - continue; - } - - // if there are other animations which fit the template anim, combine all channels into a single anim - if (!collectedAnimIndices.empty()) { - aiAnimation *combinedAnim = new aiAnimation(); - combinedAnim->mName = aiString(std::string("combinedAnim_") + char('0' + a)); - combinedAnim->mDuration = templateAnim->mDuration; - combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond; - combinedAnim->mNumChannels = static_cast(collectedAnimIndices.size() + 1); - combinedAnim->mChannels = new aiNodeAnim *[combinedAnim->mNumChannels]; - // add the template anim as first channel by moving its aiNodeAnim to the combined animation - combinedAnim->mChannels[0] = templateAnim->mChannels[0]; - templateAnim->mChannels[0] = nullptr; - delete templateAnim; - // combined animation replaces template animation in the anim array - mAnims[a] = combinedAnim; - - // move the memory of all other anims to the combined anim and erase them from the source anims - for (size_t b = 0; b < collectedAnimIndices.size(); ++b) { - aiAnimation *srcAnimation = mAnims[collectedAnimIndices[b]]; - combinedAnim->mChannels[1 + b] = srcAnimation->mChannels[0]; - srcAnimation->mChannels[0] = nullptr; - delete srcAnimation; - } - - // in a second go, delete all the single-channel-anims that we've stripped from their channels - // back to front to preserve indices - you know, removing an element from a vector moves all elements behind the removed one - while (!collectedAnimIndices.empty()) { - mAnims.erase(mAnims.begin() + collectedAnimIndices.back()); - collectedAnimIndices.pop_back(); - } - } - } - } - - // now store all anims in the scene - if (!mAnims.empty()) { - pScene->mNumAnimations = static_cast(mAnims.size()); - pScene->mAnimations = new aiAnimation *[mAnims.size()]; - std::copy(mAnims.begin(), mAnims.end(), pScene->mAnimations); - } - - mAnims.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Constructs the animations for the given source anim -void ColladaLoader::StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pPrefix) { - std::string animName = pPrefix.empty() ? pSrcAnim->mName : pPrefix + "_" + pSrcAnim->mName; - - // create nested animations, if given - for (auto mSubAnim : pSrcAnim->mSubAnims) { - StoreAnimations(pScene, pParser, mSubAnim, animName); - } - - // create animation channels, if any - if (!pSrcAnim->mChannels.empty()) { - CreateAnimation(pScene, pParser, pSrcAnim, animName); - } -} - -struct MorphTimeValues { - float mTime; - struct key { - float mWeight; - unsigned int mValue; - }; - std::vector mKeys; -}; - -void insertMorphTimeValue(std::vector &values, float time, float weight, unsigned int value) { - MorphTimeValues::key k; - k.mValue = value; - k.mWeight = weight; - if (values.empty() || time < values[0].mTime) { - MorphTimeValues val; - val.mTime = time; - val.mKeys.push_back(k); - values.insert(values.begin(), val); - return; - } - if (time > values.back().mTime) { - MorphTimeValues val; - val.mTime = time; - val.mKeys.push_back(k); - values.insert(values.end(), val); - return; - } - for (unsigned int i = 0; i < values.size(); i++) { - if (std::abs(time - values[i].mTime) < ai_epsilon) { - values[i].mKeys.push_back(k); - return; - } else if (time > values[i].mTime && time < values[i + 1].mTime) { - MorphTimeValues val; - val.mTime = time; - val.mKeys.push_back(k); - values.insert(values.begin() + i, val); - return; - } - } -} - -static float getWeightAtKey(const std::vector &values, int key, unsigned int value) { - for (auto mKey : values[key].mKeys) { - if (mKey.mValue == value) { - return mKey.mWeight; - } - } - // no value at key found, try to interpolate if present at other keys. if not, return zero - // TODO: interpolation - return 0.0f; -} - -// ------------------------------------------------------------------------------------------------ -// Constructs the animation for the given source anim -void ColladaLoader::CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Animation *pSrcAnim, const std::string &pName) { - // collect a list of animatable nodes - std::vector nodes; - CollectNodes(pScene->mRootNode, nodes); - - std::vector anims; - std::vector morphAnims; - - for (auto node : nodes) { - // find all the collada anim channels which refer to the current node - std::vector entries; - std::string nodeName = node->mName.data; - - // find the collada node corresponding to the aiNode - const Node *srcNode = FindNode(pParser.mRootNode, nodeName); - if (!srcNode) { - continue; - } - - // now check all channels if they affect the current node - std::string targetID, subElement; - for (std::vector::const_iterator cit = pSrcAnim->mChannels.begin(); - cit != pSrcAnim->mChannels.end(); ++cit) { - const AnimationChannel &srcChannel = *cit; - ChannelEntry entry; - - // we expect the animation target to be of type "nodeName/transformID.subElement". Ignore all others - // find the slash that separates the node name - there should be only one - std::string::size_type slashPos = srcChannel.mTarget.find('/'); - if (slashPos == std::string::npos) { - std::string::size_type targetPos = srcChannel.mTarget.find(srcNode->mID); - if (targetPos == std::string::npos) { - continue; - } - - // not node transform, but something else. store as unknown animation channel for now - entry.mChannel = &(*cit); - entry.mTargetId = srcChannel.mTarget.substr(targetPos + pSrcAnim->mName.length(), - srcChannel.mTarget.length() - targetPos - pSrcAnim->mName.length()); - if (entry.mTargetId.front() == '-') { - entry.mTargetId = entry.mTargetId.substr(1); - } - entries.push_back(entry); - continue; - } - if (srcChannel.mTarget.find('/', slashPos + 1) != std::string::npos) { - continue; - } - - targetID.clear(); - targetID = srcChannel.mTarget.substr(0, slashPos); - if (targetID != srcNode->mID) { - continue; - } - - // find the dot that separates the transformID - there should be only one or zero - std::string::size_type dotPos = srcChannel.mTarget.find('.'); - if (dotPos != std::string::npos) { - if (srcChannel.mTarget.find('.', dotPos + 1) != std::string::npos) { - continue; - } - - entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, dotPos - slashPos - 1); - - subElement.clear(); - subElement = srcChannel.mTarget.substr(dotPos + 1); - if (subElement == "ANGLE") - entry.mSubElement = 3; // last number in an Axis-Angle-Transform is the angle - else if (subElement == "X") - entry.mSubElement = 0; - else if (subElement == "Y") - entry.mSubElement = 1; - else if (subElement == "Z") - entry.mSubElement = 2; - else - ASSIMP_LOG_WARN("Unknown anim subelement <", subElement, ">. Ignoring"); - } else { - // no sub-element following, transformId is remaining string - entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1); - } - - std::string::size_type bracketPos = srcChannel.mTarget.find('('); - if (bracketPos != std::string::npos) { - entry.mTransformId = srcChannel.mTarget.substr(slashPos + 1, bracketPos - slashPos - 1); - subElement.clear(); - subElement = srcChannel.mTarget.substr(bracketPos); - - if (subElement == "(0)(0)") - entry.mSubElement = 0; - else if (subElement == "(1)(0)") - entry.mSubElement = 1; - else if (subElement == "(2)(0)") - entry.mSubElement = 2; - else if (subElement == "(3)(0)") - entry.mSubElement = 3; - else if (subElement == "(0)(1)") - entry.mSubElement = 4; - else if (subElement == "(1)(1)") - entry.mSubElement = 5; - else if (subElement == "(2)(1)") - entry.mSubElement = 6; - else if (subElement == "(3)(1)") - entry.mSubElement = 7; - else if (subElement == "(0)(2)") - entry.mSubElement = 8; - else if (subElement == "(1)(2)") - entry.mSubElement = 9; - else if (subElement == "(2)(2)") - entry.mSubElement = 10; - else if (subElement == "(3)(2)") - entry.mSubElement = 11; - else if (subElement == "(0)(3)") - entry.mSubElement = 12; - else if (subElement == "(1)(3)") - entry.mSubElement = 13; - else if (subElement == "(2)(3)") - entry.mSubElement = 14; - else if (subElement == "(3)(3)") - entry.mSubElement = 15; - } - - // determine which transform step is affected by this channel - entry.mTransformIndex = SIZE_MAX; - for (size_t a = 0; a < srcNode->mTransforms.size(); ++a) - if (srcNode->mTransforms[a].mID == entry.mTransformId) - entry.mTransformIndex = a; - - if (entry.mTransformIndex == SIZE_MAX) { - if (entry.mTransformId.find("morph-weights") == std::string::npos) { - continue; - } - entry.mTargetId = entry.mTransformId; - entry.mTransformId = std::string(); - } - - entry.mChannel = &(*cit); - entries.push_back(entry); - } - - // if there's no channel affecting the current node, we skip it - if (entries.empty()) { - continue; - } - - // resolve the data pointers for all anim channels. Find the minimum time while we're at it - ai_real startTime = ai_real(1e20), endTime = ai_real(-1e20); - for (ChannelEntry & e : entries) { - e.mTimeAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceTimes); - e.mTimeData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mTimeAccessor->mSource); - e.mValueAccessor = &pParser.ResolveLibraryReference(pParser.mAccessorLibrary, e.mChannel->mSourceValues); - e.mValueData = &pParser.ResolveLibraryReference(pParser.mDataLibrary, e.mValueAccessor->mSource); - - // time count and value count must match - if (e.mTimeAccessor->mCount != e.mValueAccessor->mCount) { - throw DeadlyImportError("Time count / value count mismatch in animation channel \"", e.mChannel->mTarget, "\"."); - } - - if (e.mTimeAccessor->mCount > 0) { - // find bounding times - startTime = std::min(startTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, 0, 0)); - endTime = std::max(endTime, ReadFloat(*e.mTimeAccessor, *e.mTimeData, e.mTimeAccessor->mCount - 1, 0)); - } - } - - std::vector resultTrafos; - if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) { - // create a local transformation chain of the node's transforms - std::vector transforms = srcNode->mTransforms; - - // now for every unique point in time, find or interpolate the key values for that time - // and apply them to the transform chain. Then the node's present transformation can be calculated. - ai_real time = startTime; - while (1) { - for (ChannelEntry & e : entries) { - // find the keyframe behind the current point in time - size_t pos = 0; - ai_real postTime = 0.0; - while (1) { - if (pos >= e.mTimeAccessor->mCount) { - break; - } - postTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos, 0); - if (postTime >= time) { - break; - } - ++pos; - } - - pos = std::min(pos, e.mTimeAccessor->mCount - 1); - - // read values from there - ai_real temp[16]; - for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) { - temp[c] = ReadFloat(*e.mValueAccessor, *e.mValueData, pos, c); - } - - // if not exactly at the key time, interpolate with previous value set - if (postTime > time && pos > 0) { - ai_real preTime = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos - 1, 0); - ai_real factor = (time - postTime) / (preTime - postTime); - - for (size_t c = 0; c < e.mValueAccessor->mSize; ++c) { - ai_real v = ReadFloat(*e.mValueAccessor, *e.mValueData, pos - 1, c); - temp[c] += (v - temp[c]) * factor; - } - } - - // Apply values to current transformation - std::copy(temp, temp + e.mValueAccessor->mSize, transforms[e.mTransformIndex].f + e.mSubElement); - } - - // Calculate resulting transformation - aiMatrix4x4 mat = pParser.CalculateResultTransform(transforms); - - // out of laziness: we store the time in matrix.d4 - mat.d4 = time; - resultTrafos.push_back(mat); - - // find next point in time to evaluate. That's the closest frame larger than the current in any channel - ai_real nextTime = ai_real(1e20); - for (ChannelEntry & channelElement : entries) { - // find the next time value larger than the current - size_t pos = 0; - while (pos < channelElement.mTimeAccessor->mCount) { - const ai_real t = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0); - if (t > time) { - nextTime = std::min(nextTime, t); - break; - } - ++pos; - } - - // https://github.com/assimp/assimp/issues/458 - // Sub-sample axis-angle channels if the delta between two consecutive - // key-frame angles is >= 180 degrees. - if (transforms[channelElement.mTransformIndex].mType == TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) { - const ai_real cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0); - const ai_real last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0); - const ai_real cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0); - const ai_real last_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos - 1, 0); - const ai_real last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time); - const ai_real delta = std::abs(cur_key_angle - last_eval_angle); - if (delta >= 180.0) { - const int subSampleCount = static_cast(std::floor(delta / 90.0)); - if (cur_key_time != time) { - const ai_real nextSampleTime = time + (cur_key_time - time) / subSampleCount; - nextTime = std::min(nextTime, nextSampleTime); - } - } - } - } - - // no more keys on any channel after the current time -> we're done - if (nextTime > 1e19) { - break; - } - - // else construct next key-frame at this following time point - time = nextTime; - } - } - - // build an animation channel for the given node out of these trafo keys - if (!resultTrafos.empty()) { - aiNodeAnim *dstAnim = new aiNodeAnim; - dstAnim->mNodeName = nodeName; - dstAnim->mNumPositionKeys = static_cast(resultTrafos.size()); - dstAnim->mNumRotationKeys = static_cast(resultTrafos.size()); - dstAnim->mNumScalingKeys = static_cast(resultTrafos.size()); - dstAnim->mPositionKeys = new aiVectorKey[resultTrafos.size()]; - dstAnim->mRotationKeys = new aiQuatKey[resultTrafos.size()]; - dstAnim->mScalingKeys = new aiVectorKey[resultTrafos.size()]; - - for (size_t a = 0; a < resultTrafos.size(); ++a) { - aiMatrix4x4 mat = resultTrafos[a]; - double time = double(mat.d4); // remember? time is stored in mat.d4 - mat.d4 = 1.0f; - - dstAnim->mPositionKeys[a].mTime = time * kMillisecondsFromSeconds; - dstAnim->mRotationKeys[a].mTime = time * kMillisecondsFromSeconds; - dstAnim->mScalingKeys[a].mTime = time * kMillisecondsFromSeconds; - mat.Decompose(dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue); - } - - anims.push_back(dstAnim); - } else { - ASSIMP_LOG_WARN("Collada loader: found empty animation channel, ignored. Please check your exporter."); - } - - if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) { - std::vector morphChannels; - for (ChannelEntry & e : entries) { - // skip non-transform types - if (e.mTargetId.empty()) { - continue; - } - - if (e.mTargetId.find("morph-weights") != std::string::npos) { - morphChannels.push_back(e); - } - } - if (!morphChannels.empty()) { - // either 1) morph weight animation count should contain morph target count channels - // or 2) one channel with morph target count arrays - // assume first - - aiMeshMorphAnim *morphAnim = new aiMeshMorphAnim; - morphAnim->mName.Set(nodeName); - - std::vector morphTimeValues; - int morphAnimChannelIndex = 0; - for (ChannelEntry & e : morphChannels) { - std::string::size_type apos = e.mTargetId.find('('); - std::string::size_type bpos = e.mTargetId.find(')'); - - // If unknown way to specify weight -> ignore this animation - if (apos == std::string::npos || bpos == std::string::npos) { - continue; - } - - // weight target can be in format Weight_M_N, Weight_N, WeightN, or some other way - // we ignore the name and just assume the channels are in the right order - for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++) { - insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues[i], e.mValueData->mValues[i], morphAnimChannelIndex); - } - - ++morphAnimChannelIndex; - } - - morphAnim->mNumKeys = static_cast(morphTimeValues.size()); - morphAnim->mKeys = new aiMeshMorphKey[morphAnim->mNumKeys]; - for (unsigned int key = 0; key < morphAnim->mNumKeys; key++) { - morphAnim->mKeys[key].mNumValuesAndWeights = static_cast(morphChannels.size()); - morphAnim->mKeys[key].mValues = new unsigned int[morphChannels.size()]; - morphAnim->mKeys[key].mWeights = new double[morphChannels.size()]; - - morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime * kMillisecondsFromSeconds; - for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); ++valueIndex) { - morphAnim->mKeys[key].mValues[valueIndex] = valueIndex; - morphAnim->mKeys[key].mWeights[valueIndex] = getWeightAtKey(morphTimeValues, key, valueIndex); - } - } - - morphAnims.push_back(morphAnim); - } - } - } - - if (!anims.empty() || !morphAnims.empty()) { - aiAnimation *anim = new aiAnimation; - anim->mName.Set(pName); - anim->mNumChannels = static_cast(anims.size()); - if (anim->mNumChannels > 0) { - anim->mChannels = new aiNodeAnim *[anims.size()]; - std::copy(anims.begin(), anims.end(), anim->mChannels); - } - anim->mNumMorphMeshChannels = static_cast(morphAnims.size()); - if (anim->mNumMorphMeshChannels > 0) { - anim->mMorphMeshChannels = new aiMeshMorphAnim *[anim->mNumMorphMeshChannels]; - std::copy(morphAnims.begin(), morphAnims.end(), anim->mMorphMeshChannels); - } - anim->mDuration = 0.0f; - for (auto & a : anims) { - anim->mDuration = std::max(anim->mDuration, a->mPositionKeys[a->mNumPositionKeys - 1].mTime); - anim->mDuration = std::max(anim->mDuration, a->mRotationKeys[a->mNumRotationKeys - 1].mTime); - anim->mDuration = std::max(anim->mDuration, a->mScalingKeys[a->mNumScalingKeys - 1].mTime); - } - for (auto & morphAnim : morphAnims) { - anim->mDuration = std::max(anim->mDuration, morphAnim->mKeys[morphAnim->mNumKeys - 1].mTime); - } - anim->mTicksPerSecond = 1000.0; - mAnims.push_back(anim); - } -} - -// ------------------------------------------------------------------------------------------------ -// Add a texture to a material structure -void ColladaLoader::AddTexture(aiMaterial &mat, - const ColladaParser &pParser, - const Effect &effect, - const Sampler &sampler, - aiTextureType type, - unsigned int idx) { - // first of all, basic file name - const aiString name = FindFilenameForEffectTexture(pParser, effect, sampler.mName); - mat.AddProperty(&name, _AI_MATKEY_TEXTURE_BASE, type, idx); - - // mapping mode - int map = aiTextureMapMode_Clamp; - if (sampler.mWrapU) { - map = aiTextureMapMode_Wrap; - } - if (sampler.mWrapU && sampler.mMirrorU) { - map = aiTextureMapMode_Mirror; - } - - mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_U_BASE, type, idx); - - map = aiTextureMapMode_Clamp; - if (sampler.mWrapV) { - map = aiTextureMapMode_Wrap; - } - if (sampler.mWrapV && sampler.mMirrorV) { - map = aiTextureMapMode_Mirror; - } - - mat.AddProperty(&map, 1, _AI_MATKEY_MAPPINGMODE_V_BASE, type, idx); - - // UV transformation - mat.AddProperty(&sampler.mTransform, 1, - _AI_MATKEY_UVTRANSFORM_BASE, type, idx); - - // Blend mode - mat.AddProperty((int *)&sampler.mOp, 1, - _AI_MATKEY_TEXBLEND_BASE, type, idx); - - // Blend factor - mat.AddProperty((ai_real *)&sampler.mWeighting, 1, - _AI_MATKEY_TEXBLEND_BASE, type, idx); - - // UV source index ... if we didn't resolve the mapping, it is actually just - // a guess but it works in most cases. We search for the frst occurrence of a - // number in the channel name. We assume it is the zero-based index into the - // UV channel array of all corresponding meshes. It could also be one-based - // for some exporters, but we won't care of it unless someone complains about. - if (sampler.mUVId != UINT_MAX) { - map = sampler.mUVId; - } else { - map = -1; - for (std::string::const_iterator it = sampler.mUVChannel.begin(); it != sampler.mUVChannel.end(); ++it) { - if (IsNumeric(*it)) { - map = strtoul10(&(*it)); - break; - } - } - if (-1 == map) { - ASSIMP_LOG_WARN("Collada: unable to determine UV channel for texture"); - map = 0; - } - } - mat.AddProperty(&map, 1, _AI_MATKEY_UVWSRC_BASE, type, idx); -} - -// ------------------------------------------------------------------------------------------------ -// Fills materials from the collada material definitions -void ColladaLoader::FillMaterials(const ColladaParser &pParser, aiScene * /*pScene*/) { - for (auto &elem : newMats) { - aiMaterial &mat = (aiMaterial &)*elem.second; - Collada::Effect &effect = *elem.first; - - // resolve shading mode - int shadeMode; - if (effect.mFaceted) { - shadeMode = aiShadingMode_Flat; - } else { - switch (effect.mShadeType) { - case Collada::Shade_Constant: - shadeMode = aiShadingMode_NoShading; - break; - case Collada::Shade_Lambert: - shadeMode = aiShadingMode_Gouraud; - break; - case Collada::Shade_Blinn: - shadeMode = aiShadingMode_Blinn; - break; - case Collada::Shade_Phong: - shadeMode = aiShadingMode_Phong; - break; - - default: - ASSIMP_LOG_WARN("Collada: Unrecognized shading mode, using gouraud shading"); - shadeMode = aiShadingMode_Gouraud; - break; - } - } - mat.AddProperty(&shadeMode, 1, AI_MATKEY_SHADING_MODEL); - - // double-sided? - shadeMode = effect.mDoubleSided; - mat.AddProperty(&shadeMode, 1, AI_MATKEY_TWOSIDED); - - // wire-frame? - shadeMode = effect.mWireframe; - mat.AddProperty(&shadeMode, 1, AI_MATKEY_ENABLE_WIREFRAME); - - // add material colors - mat.AddProperty(&effect.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT); - mat.AddProperty(&effect.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE); - mat.AddProperty(&effect.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR); - mat.AddProperty(&effect.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE); - mat.AddProperty(&effect.mReflective, 1, AI_MATKEY_COLOR_REFLECTIVE); - - // scalar properties - mat.AddProperty(&effect.mShininess, 1, AI_MATKEY_SHININESS); - mat.AddProperty(&effect.mReflectivity, 1, AI_MATKEY_REFLECTIVITY); - mat.AddProperty(&effect.mRefractIndex, 1, AI_MATKEY_REFRACTI); - - // transparency, a very hard one. seemingly not all files are following the - // specification here (1.0 transparency => completely opaque)... - // therefore, we let the opportunity for the user to manually invert - // the transparency if necessary and we add preliminary support for RGB_ZERO mode - if (effect.mTransparency >= 0.f && effect.mTransparency <= 1.f) { - // handle RGB transparency completely, cf Collada specs 1.5.0 pages 249 and 304 - if (effect.mRGBTransparency) { - // use luminance as defined by ISO/CIE color standards (see ITU-R Recommendation BT.709-4) - effect.mTransparency *= (0.212671f * effect.mTransparent.r + - 0.715160f * effect.mTransparent.g + - 0.072169f * effect.mTransparent.b); - - effect.mTransparent.a = 1.f; - - mat.AddProperty(&effect.mTransparent, 1, AI_MATKEY_COLOR_TRANSPARENT); - } else { - effect.mTransparency *= effect.mTransparent.a; - } - - if (effect.mInvertTransparency) { - effect.mTransparency = 1.f - effect.mTransparency; - } - - // Is the material finally transparent ? - if (effect.mHasTransparency || effect.mTransparency < 1.f) { - mat.AddProperty(&effect.mTransparency, 1, AI_MATKEY_OPACITY); - } - } - - // add textures, if given - if (!effect.mTexAmbient.mName.empty()) { - // It is merely a light-map - AddTexture(mat, pParser, effect, effect.mTexAmbient, aiTextureType_LIGHTMAP); - } - - if (!effect.mTexEmissive.mName.empty()) - AddTexture(mat, pParser, effect, effect.mTexEmissive, aiTextureType_EMISSIVE); - - if (!effect.mTexSpecular.mName.empty()) - AddTexture(mat, pParser, effect, effect.mTexSpecular, aiTextureType_SPECULAR); - - if (!effect.mTexDiffuse.mName.empty()) - AddTexture(mat, pParser, effect, effect.mTexDiffuse, aiTextureType_DIFFUSE); - - if (!effect.mTexBump.mName.empty()) - AddTexture(mat, pParser, effect, effect.mTexBump, aiTextureType_NORMALS); - - if (!effect.mTexTransparent.mName.empty()) - AddTexture(mat, pParser, effect, effect.mTexTransparent, aiTextureType_OPACITY); - - if (!effect.mTexReflective.mName.empty()) - AddTexture(mat, pParser, effect, effect.mTexReflective, aiTextureType_REFLECTION); - } -} - -// ------------------------------------------------------------------------------------------------ -// Constructs materials from the collada material definitions -void ColladaLoader::BuildMaterials(ColladaParser &pParser, aiScene * /*pScene*/) { - newMats.reserve(pParser.mMaterialLibrary.size()); - - for (ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin(); - matIt != pParser.mMaterialLibrary.end(); ++matIt) { - const Material &material = matIt->second; - // a material is only a reference to an effect - ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find(material.mEffect); - if (effIt == pParser.mEffectLibrary.end()) - continue; - Effect &effect = effIt->second; - - // create material - aiMaterial *mat = new aiMaterial; - aiString name(material.mName.empty() ? matIt->first : material.mName); - mat->AddProperty(&name, AI_MATKEY_NAME); - - // store the material - mMaterialIndexByName[matIt->first] = newMats.size(); - newMats.emplace_back(&effect, mat); - } - // ScenePreprocessor generates a default material automatically if none is there. - // All further code here in this loader works well without a valid material so - // we can safely let it to ScenePreprocessor. -} - -// ------------------------------------------------------------------------------------------------ -// Resolves the texture name for the given effect texture entry and loads the texture data -aiString ColladaLoader::FindFilenameForEffectTexture(const ColladaParser &pParser, - const Effect &pEffect, const std::string &pName) { - aiString result; - - // recurse through the param references until we end up at an image - std::string name = pName; - while (1) { - // the given string is a param entry. Find it - Effect::ParamLibrary::const_iterator it = pEffect.mParams.find(name); - // if not found, we're at the end of the recursion. The resulting string should be the image ID - if (it == pEffect.mParams.end()) - break; - - // else recurse on - name = it->second.mReference; - } - - // find the image referred by this name in the image library of the scene - ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find(name); - if (imIt == pParser.mImageLibrary.end()) { - ASSIMP_LOG_WARN("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\"."); - - //set default texture file name - result.Set(name + ".jpg"); - ColladaParser::UriDecodePath(result); - return result; - } - - // if this is an embedded texture image setup an aiTexture for it - if (!imIt->second.mImageData.empty()) { - aiTexture *tex = new aiTexture(); - - // Store embedded texture name reference - tex->mFilename.Set(imIt->second.mFileName.c_str()); - result.Set(imIt->second.mFileName); - - // setup format hint - if (imIt->second.mEmbeddedFormat.length() >= HINTMAXTEXTURELEN) { - ASSIMP_LOG_WARN("Collada: texture format hint is too long, truncating to 3 characters"); - } - strncpy(tex->achFormatHint, imIt->second.mEmbeddedFormat.c_str(), 3); - - // and copy texture data - tex->mHeight = 0; - tex->mWidth = static_cast(imIt->second.mImageData.size()); - tex->pcData = (aiTexel *)new char[tex->mWidth]; - memcpy(tex->pcData, &imIt->second.mImageData[0], tex->mWidth); - - // and add this texture to the list - mTextures.push_back(tex); - return result; - } - - if (imIt->second.mFileName.empty()) { - throw DeadlyImportError("Collada: Invalid texture, no data or file reference given"); - } - - result.Set(imIt->second.mFileName); - - return result; -} - -// ------------------------------------------------------------------------------------------------ -// Reads a float value from an accessor and its data array. -ai_real ColladaLoader::ReadFloat(const Accessor &pAccessor, const Data &pData, size_t pIndex, size_t pOffset) const { - size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset + pOffset; - ai_assert(pos < pData.mValues.size()); - return pData.mValues[pos]; -} - -// ------------------------------------------------------------------------------------------------ -// Reads a string value from an accessor and its data array. -const std::string &ColladaLoader::ReadString(const Accessor &pAccessor, const Data &pData, size_t pIndex) const { - size_t pos = pAccessor.mStride * pIndex + pAccessor.mOffset; - ai_assert(pos < pData.mStrings.size()); - return pData.mStrings[pos]; -} - -// ------------------------------------------------------------------------------------------------ -// Collects all nodes into the given array -void ColladaLoader::CollectNodes(const aiNode *pNode, std::vector &poNodes) const { - poNodes.push_back(pNode); - for (size_t a = 0; a < pNode->mNumChildren; ++a) { - CollectNodes(pNode->mChildren[a], poNodes); - } -} - -// ------------------------------------------------------------------------------------------------ -// Finds a node in the collada scene by the given name -const Node *ColladaLoader::FindNode(const Node *pNode, const std::string &pName) const { - if (pNode->mName == pName || pNode->mID == pName) - return pNode; - - for (auto a : pNode->mChildren) { - const Collada::Node *node = FindNode(a, pName); - if (node) { - return node; - } - } - - return nullptr; -} - -// ------------------------------------------------------------------------------------------------ -// Finds a node in the collada scene by the given SID -const Node *ColladaLoader::FindNodeBySID(const Node *pNode, const std::string &pSID) const { - if (nullptr == pNode) { - return nullptr; - } - - if (pNode->mSID == pSID) { - return pNode; - } - - for (auto a : pNode->mChildren) { - const Collada::Node *node = FindNodeBySID(a, pSID); - if (node) { - return node; - } - } - - return nullptr; -} - -// ------------------------------------------------------------------------------------------------ -// Finds a proper unique name for a node derived from the collada-node's properties. -// The name must be unique for proper node-bone association. -std::string ColladaLoader::FindNameForNode(const Node *pNode) { - // If explicitly requested, just use the collada name. - if (useColladaName) { - if (!pNode->mName.empty()) { - return pNode->mName; - } else { - return format() << "$ColladaAutoName$_" << mNodeNameCounter++; - } - } else { - // Now setup the name of the assimp node. The collada name might not be - // unique, so we use the collada ID. - if (!pNode->mID.empty()) - return pNode->mID; - else if (!pNode->mSID.empty()) - return pNode->mSID; - else { - // No need to worry. Unnamed nodes are no problem at all, except - // if cameras or lights need to be assigned to them. - return format() << "$ColladaAutoName$_" << mNodeNameCounter++; - } - } -} - -} // Namespace Assimp - -#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h deleted file mode 100644 index 246abed..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaLoader.h +++ /dev/null @@ -1,249 +0,0 @@ -/** Defines the collada loader class */ - -/* -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. - ----------------------------------------------------------------------- -*/ - -#ifndef AI_COLLADALOADER_H_INC -#define AI_COLLADALOADER_H_INC - -#include "ColladaParser.h" -#include - -struct aiNode; -struct aiCamera; -struct aiLight; -struct aiTexture; -struct aiAnimation; - -namespace Assimp { - -struct ColladaMeshIndex { - std::string mMeshID; - size_t mSubMesh; - std::string mMaterial; - ColladaMeshIndex(const std::string &pMeshID, size_t pSubMesh, const std::string &pMaterial) : - mMeshID(pMeshID), mSubMesh(pSubMesh), mMaterial(pMaterial) { - ai_assert(!pMeshID.empty()); - } - - bool operator<(const ColladaMeshIndex &p) const { - if (mMeshID == p.mMeshID) { - if (mSubMesh == p.mSubMesh) - return mMaterial < p.mMaterial; - else - return mSubMesh < p.mSubMesh; - } else { - return mMeshID < p.mMeshID; - } - } -}; - -/** Loader class to read Collada scenes. Collada is over-engineered to death, with every new iteration bringing - * more useless stuff, so I limited the data to what I think is useful for games. -*/ -class ColladaLoader : public BaseImporter { -public: - /// The class constructor. - ColladaLoader(); - - /// The class destructor. - ~ColladaLoader() override; - - /// Returns whether the class can handle the format of the given file. - /// @see BaseImporter::CanRead() for more details. - bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const override; - -protected: - /// See #BaseImporter::GetInfo for the details - const aiImporterDesc *GetInfo() const override; - - /// See #BaseImporter::SetupProperties for the details - void SetupProperties(const Importer *pImp) override; - - /// See #BaseImporter::InternReadFile for the details - void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) override; - - /** Recursively constructs a scene node for the given parser node and returns it. */ - aiNode *BuildHierarchy(const ColladaParser &pParser, const Collada::Node *pNode); - - /** Resolve node instances */ - void ResolveNodeInstances(const ColladaParser &pParser, const Collada::Node *pNode, - std::vector &resolved); - - /** Builds meshes for the given node and references them */ - void BuildMeshesForNode(const ColladaParser &pParser, const Collada::Node *pNode, - aiNode *pTarget); - - aiMesh *findMesh(const std::string &meshid); - - /** Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh */ - aiMesh *CreateMesh(const ColladaParser &pParser, const Collada::Mesh *pSrcMesh, const Collada::SubMesh &pSubMesh, - const Collada::Controller *pSrcController, size_t pStartVertex, size_t pStartFace); - - /** Builds cameras for the given node and references them */ - void BuildCamerasForNode(const ColladaParser &pParser, const Collada::Node *pNode, - aiNode *pTarget); - - /** Builds lights for the given node and references them */ - void BuildLightsForNode(const ColladaParser &pParser, const Collada::Node *pNode, - aiNode *pTarget); - - /** Stores all meshes in the given scene */ - void StoreSceneMeshes(aiScene *pScene); - - /** Stores all materials in the given scene */ - void StoreSceneMaterials(aiScene *pScene); - - /** Stores all lights in the given scene */ - void StoreSceneLights(aiScene *pScene); - - /** Stores all cameras in the given scene */ - void StoreSceneCameras(aiScene *pScene); - - /** Stores all textures in the given scene */ - void StoreSceneTextures(aiScene *pScene); - - /** Stores all animations - * @param pScene target scene to store the anims - */ - void StoreAnimations(aiScene *pScene, const ColladaParser &pParser); - - /** Stores all animations for the given source anim and its nested child animations - * @param pScene target scene to store the anims - * @param pSrcAnim the source animation to process - * @param pPrefix Prefix to the name in case of nested animations - */ - void StoreAnimations(aiScene *pScene, const ColladaParser &pParser, const Collada::Animation *pSrcAnim, const std::string &pPrefix); - - /** Constructs the animation for the given source anim */ - void CreateAnimation(aiScene *pScene, const ColladaParser &pParser, const Collada::Animation *pSrcAnim, const std::string &pName); - - /** Constructs materials from the collada material definitions */ - void BuildMaterials(ColladaParser &pParser, aiScene *pScene); - - /** Fill materials from the collada material definitions */ - void FillMaterials(const ColladaParser &pParser, aiScene *pScene); - - /** Resolve UV channel mappings*/ - void ApplyVertexToEffectSemanticMapping(Collada::Sampler &sampler, - const Collada::SemanticMappingTable &table); - - /** Add a texture and all of its sampling properties to a material*/ - void AddTexture(aiMaterial &mat, const ColladaParser &pParser, - const Collada::Effect &effect, - const Collada::Sampler &sampler, - aiTextureType type, unsigned int idx = 0); - - /** Resolves the texture name for the given effect texture entry */ - aiString FindFilenameForEffectTexture(const ColladaParser &pParser, - const Collada::Effect &pEffect, const std::string &pName); - - /** Reads a float value from an accessor and its data array. - * @param pAccessor The accessor to use for reading - * @param pData The data array to read from - * @param pIndex The index of the element to retrieve - * @param pOffset Offset into the element, for multipart elements such as vectors or matrices - * @return the specified value - */ - ai_real ReadFloat(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex, size_t pOffset) const; - - /** Reads a string value from an accessor and its data array. - * @param pAccessor The accessor to use for reading - * @param pData The data array to read from - * @param pIndex The index of the element to retrieve - * @return the specified value - */ - const std::string &ReadString(const Collada::Accessor &pAccessor, const Collada::Data &pData, size_t pIndex) const; - - /** Recursively collects all nodes into the given array */ - void CollectNodes(const aiNode *pNode, std::vector &poNodes) const; - - /** Finds a node in the collada scene by the given name */ - const Collada::Node *FindNode(const Collada::Node *pNode, const std::string &pName) const; - /** Finds a node in the collada scene by the given SID */ - const Collada::Node *FindNodeBySID(const Collada::Node *pNode, const std::string &pSID) const; - - /** Finds a proper name for a node derived from the collada-node's properties */ - std::string FindNameForNode(const Collada::Node *pNode); - -protected: - /** Filename, for a verbose error message */ - std::string mFileName; - - /** Which mesh-material compound was stored under which mesh ID */ - std::map mMeshIndexByID; - - /** Which material was stored under which index in the scene */ - std::map mMaterialIndexByName; - - /** Accumulated meshes for the target scene */ - std::vector mMeshes; - - /** Accumulated morph target meshes */ - std::vector mTargetMeshes; - - /** Temporary material list */ - std::vector> newMats; - - /** Temporary camera list */ - std::vector mCameras; - - /** Temporary light list */ - std::vector mLights; - - /** Temporary texture list */ - std::vector mTextures; - - /** Accumulated animations for the target scene */ - std::vector mAnims; - - bool noSkeletonMesh; - bool ignoreUpDirection; - bool useColladaName; - - /** Used by FindNameForNode() to generate unique node names */ - unsigned int mNodeNameCounter; -}; - -} // end of namespace Assimp - -#endif // AI_COLLADALOADER_H_INC diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp deleted file mode 100644 index 922d1f6..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.cpp +++ /dev/null @@ -1,2402 +0,0 @@ -/* ---------------------------------------------------------------------------- -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 ColladaParser.cpp - * @brief Implementation of the Collada parser helper - */ - -#ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER - -#include "ColladaParser.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include - -using namespace Assimp; -using namespace Assimp::Collada; -using namespace Assimp::Formatter; - -static void ReportWarning(const char *msg, ...) { - ai_assert(nullptr != msg); - - va_list args; - va_start(args, msg); - - char szBuffer[3000]; - const int iLen = vsprintf(szBuffer, msg, args); - ai_assert(iLen > 0); - - va_end(args); - ASSIMP_LOG_WARN("Validation warning: ", std::string(szBuffer, iLen)); -} - -static bool FindCommonKey(const std::string &collada_key, const MetaKeyPairVector &key_renaming, size_t &found_index) { - for (size_t i = 0; i < key_renaming.size(); ++i) { - if (key_renaming[i].first == collada_key) { - found_index = i; - return true; - } - } - found_index = std::numeric_limits::max(); - - return false; -} - -static void readUrlAttribute(XmlNode &node, std::string &url) { - url.clear(); - if (!XmlParser::getStdStrAttribute(node, "url", url)) { - return; - } - if (url[0] != '#') { - throw DeadlyImportError("Unknown reference format"); - } - url = url.c_str() + 1; -} - -// ------------------------------------------------------------------------------------------------ -// Constructor to be privately used by Importer -ColladaParser::ColladaParser(IOSystem *pIOHandler, const std::string &pFile) : - mFileName(pFile), - mXmlParser(), - mDataLibrary(), - mAccessorLibrary(), - mMeshLibrary(), - mNodeLibrary(), - mImageLibrary(), - mEffectLibrary(), - mMaterialLibrary(), - mLightLibrary(), - mCameraLibrary(), - mControllerLibrary(), - mRootNode(nullptr), - mAnims(), - mUnitSize(1.0f), - mUpDirection(UP_Y), - mFormat(FV_1_5_n) { - if (nullptr == pIOHandler) { - throw DeadlyImportError("IOSystem is nullptr."); - } - - std::unique_ptr daefile; - std::unique_ptr zip_archive; - - // Determine type - std::string extension = BaseImporter::GetExtension(pFile); - if (extension != "dae") { - zip_archive.reset(new ZipArchiveIOSystem(pIOHandler, pFile)); - } - - if (zip_archive && zip_archive->isOpen()) { - std::string dae_filename = ReadZaeManifest(*zip_archive); - - if (dae_filename.empty()) { - throw DeadlyImportError("Invalid ZAE"); - } - - daefile.reset(zip_archive->Open(dae_filename.c_str())); - if (daefile == nullptr) { - throw DeadlyImportError("Invalid ZAE manifest: '", dae_filename, "' is missing"); - } - } else { - // attempt to open the file directly - daefile.reset(pIOHandler->Open(pFile)); - if (daefile.get() == nullptr) { - throw DeadlyImportError("Failed to open file '", pFile, "'."); - } - } - - // generate a XML reader for it - if (!mXmlParser.parse(daefile.get())) { - throw DeadlyImportError("Unable to read file, malformed XML"); - } - // start reading - XmlNode node = mXmlParser.getRootNode(); - XmlNode colladaNode = node.child("COLLADA"); - if (colladaNode.empty()) { - return; - } - - // Read content and embedded textures - ReadContents(colladaNode); - if (zip_archive && zip_archive->isOpen()) { - ReadEmbeddedTextures(*zip_archive); - } -} - -// ------------------------------------------------------------------------------------------------ -// Destructor, private as well -ColladaParser::~ColladaParser() { - for (auto &it : mNodeLibrary) { - delete it.second; - } - for (auto &it : mMeshLibrary) { - delete it.second; - } -} - -// ------------------------------------------------------------------------------------------------ -// Read a ZAE manifest and return the filename to attempt to open -std::string ColladaParser::ReadZaeManifest(ZipArchiveIOSystem &zip_archive) { - // Open the manifest - std::unique_ptr manifestfile(zip_archive.Open("manifest.xml")); - if (manifestfile == nullptr) { - // No manifest, hope there is only one .DAE inside - std::vector file_list; - zip_archive.getFileListExtension(file_list, "dae"); - - if (file_list.empty()) { - return std::string(); - } - - return file_list.front(); - } - XmlParser manifestParser; - if (!manifestParser.parse(manifestfile.get())) { - return std::string(); - } - - XmlNode root = manifestParser.getRootNode(); - const std::string &name = root.name(); - if (name != "dae_root") { - root = *manifestParser.findNode("dae_root"); - if (nullptr == root) { - return std::string(); - } - std::string v; - XmlParser::getValueAsString(root, v); - aiString ai_str(v); - UriDecodePath(ai_str); - return std::string(ai_str.C_Str()); - } - - return std::string(); -} - -// ------------------------------------------------------------------------------------------------ -// Convert a path read from a collada file to the usual representation -void ColladaParser::UriDecodePath(aiString &ss) { - // TODO: collada spec, p 22. Handle URI correctly. - // For the moment we're just stripping the file:// away to make it work. - // Windows doesn't seem to be able to find stuff like - // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg' - if (0 == strncmp(ss.data, "file://", 7)) { - ss.length -= 7; - memmove(ss.data, ss.data + 7, ss.length); - ss.data[ss.length] = '\0'; - } - - // Maxon Cinema Collada Export writes "file:///C:\andsoon" with three slashes... - // I need to filter it without destroying linux paths starting with "/somewhere" - if (ss.data[0] == '/' && isalpha((unsigned char)ss.data[1]) && ss.data[2] == ':') { - --ss.length; - ::memmove(ss.data, ss.data + 1, ss.length); - ss.data[ss.length] = 0; - } - - // find and convert all %xy special chars - char *out = ss.data; - for (const char *it = ss.data; it != ss.data + ss.length; /**/) { - if (*it == '%' && (it + 3) < ss.data + ss.length) { - // separate the number to avoid dragging in chars from behind into the parsing - char mychar[3] = { it[1], it[2], 0 }; - size_t nbr = strtoul16(mychar); - it += 3; - *out++ = (char)(nbr & 0xFF); - } else { - *out++ = *it++; - } - } - - // adjust length and terminator of the shortened string - *out = 0; - ai_assert(out > ss.data); - ss.length = static_cast(out - ss.data); -} - -// ------------------------------------------------------------------------------------------------ -// Reads the contents of the file -void ColladaParser::ReadContents(XmlNode &node) { - const std::string name = node.name(); - if (name == "COLLADA") { - std::string version; - if (XmlParser::getStdStrAttribute(node, "version", version)) { - aiString v; - v.Set(version.c_str()); - mAssetMetaData.emplace(AI_METADATA_SOURCE_FORMAT_VERSION, v); - if (!::strncmp(version.c_str(), "1.5", 3)) { - mFormat = FV_1_5_n; - ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n"); - } else if (!::strncmp(version.c_str(), "1.4", 3)) { - mFormat = FV_1_4_n; - ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n"); - } else if (!::strncmp(version.c_str(), "1.3", 3)) { - mFormat = FV_1_3_n; - ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n"); - } - } - ReadStructure(node); - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the structure of the file -void ColladaParser::ReadStructure(XmlNode &node) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "asset") { - ReadAssetInfo(currentNode); - } else if (currentName == "library_animations") { - ReadAnimationLibrary(currentNode); - } else if (currentName == "library_animation_clips") { - ReadAnimationClipLibrary(currentNode); - } else if (currentName == "library_controllers") { - ReadControllerLibrary(currentNode); - } else if (currentName == "library_images") { - ReadImageLibrary(currentNode); - } else if (currentName == "library_materials") { - ReadMaterialLibrary(currentNode); - } else if (currentName == "library_effects") { - ReadEffectLibrary(currentNode); - } else if (currentName == "library_geometries") { - ReadGeometryLibrary(currentNode); - } else if (currentName == "library_visual_scenes") { - ReadSceneLibrary(currentNode); - } else if (currentName == "library_lights") { - ReadLightLibrary(currentNode); - } else if (currentName == "library_cameras") { - ReadCameraLibrary(currentNode); - } else if (currentName == "library_nodes") { - ReadSceneNode(currentNode, nullptr); /* some hacking to reuse this piece of code */ - } else if (currentName == "scene") { - ReadScene(currentNode); - } - } - - PostProcessRootAnimations(); - PostProcessControllers(); -} - -// ------------------------------------------------------------------------------------------------ -// Reads asset information such as coordinate system information and legal blah -void ColladaParser::ReadAssetInfo(XmlNode &node) { - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "unit") { - mUnitSize = 1.f; - std::string tUnitSizeString; - if (XmlParser::getStdStrAttribute(currentNode, "meter", tUnitSizeString)) { - try { - fast_atoreal_move(tUnitSizeString.data(), mUnitSize); - } catch (const DeadlyImportError& die) { - std::string warning("Collada: Failed to parse meter parameter to real number. Exception:\n"); - warning.append(die.what()); - ASSIMP_LOG_WARN(warning.data()); - } - } - } else if (currentName == "up_axis") { - std::string v; - if (!XmlParser::getValueAsString(currentNode, v)) { - continue; - } - if (v == "X_UP") { - mUpDirection = UP_X; - } else if (v == "Z_UP") { - mUpDirection = UP_Z; - } else { - mUpDirection = UP_Y; - } - } else if (currentName == "contributor") { - for (XmlNode currentChildNode : currentNode.children()) { - ReadMetaDataItem(currentChildNode, mAssetMetaData); - } - } else { - ReadMetaDataItem(currentNode, mAssetMetaData); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a single string metadata item -void ColladaParser::ReadMetaDataItem(XmlNode &node, StringMetaData &metadata) { - const Collada::MetaKeyPairVector &key_renaming = GetColladaAssimpMetaKeysCamelCase(); - const std::string name = node.name(); - if (name.empty()) { - return; - } - - std::string v; - if (!XmlParser::getValueAsString(node, v)) { - return; - } - - v = ai_trim(v); - aiString aistr; - aistr.Set(v); - - std::string camel_key_str(name); - ToCamelCase(camel_key_str); - - size_t found_index; - if (FindCommonKey(camel_key_str, key_renaming, found_index)) { - metadata.emplace(key_renaming[found_index].second, aistr); - } else { - metadata.emplace(camel_key_str, aistr); - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the animation clips -void ColladaParser::ReadAnimationClipLibrary(XmlNode &node) { - if (node.empty()) { - return; - } - - std::string animName; - if (!XmlParser::getStdStrAttribute(node, "name", animName)) { - if (!XmlParser::getStdStrAttribute(node, "id", animName)) { - animName = std::string("animation_") + ai_to_string(mAnimationClipLibrary.size()); - } - } - - std::pair> clip; - clip.first = animName; - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "instance_animation") { - std::string url; - readUrlAttribute(currentNode, url); - clip.second.push_back(url); - } - - if (clip.second.size() > 0) { - mAnimationClipLibrary.push_back(clip); - } - } -} - -void ColladaParser::PostProcessControllers() { - std::string meshId; - for (auto &it : mControllerLibrary) { - meshId = it.second.mMeshId; - if (meshId.empty()) { - continue; - } - - ControllerLibrary::iterator findItr = mControllerLibrary.find(meshId); - while (findItr != mControllerLibrary.end()) { - meshId = findItr->second.mMeshId; - findItr = mControllerLibrary.find(meshId); - } - - it.second.mMeshId = meshId; - } -} - -// ------------------------------------------------------------------------------------------------ -// Re-build animations from animation clip library, if present, otherwise combine single-channel animations -void ColladaParser::PostProcessRootAnimations() { - if (mAnimationClipLibrary.empty()) { - mAnims.CombineSingleChannelAnimations(); - return; - } - - Animation temp; - for (auto &it : mAnimationClipLibrary) { - std::string clipName = it.first; - - Animation *clip = new Animation(); - clip->mName = clipName; - - temp.mSubAnims.push_back(clip); - - for (const std::string &animationID : it.second) { - AnimationLibrary::iterator animation = mAnimationLibrary.find(animationID); - - if (animation != mAnimationLibrary.end()) { - Animation *pSourceAnimation = animation->second; - pSourceAnimation->CollectChannelsRecursively(clip->mChannels); - } - } - } - - mAnims = temp; - - // Ensure no double deletes. - temp.mSubAnims.clear(); -} - -// ------------------------------------------------------------------------------------------------ -// Reads the animation library -void ColladaParser::ReadAnimationLibrary(XmlNode &node) { - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "animation") { - ReadAnimation(currentNode, &mAnims); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an animation into the given parent structure -void ColladaParser::ReadAnimation(XmlNode &node, Collada::Animation *pParent) { - if (node.empty()) { - return; - } - - // an element may be a container for grouping sub-elements or an animation channel - // this is the channel collection by ID, in case it has channels - using ChannelMap = std::map; - ChannelMap channels; - // this is the anim container in case we're a container - Animation *anim = nullptr; - - // optional name given as an attribute - std::string animName; - if (!XmlParser::getStdStrAttribute(node, "name", animName)) { - animName = "animation"; - } - - std::string animID; - pugi::xml_attribute idAttr = node.attribute("id"); - if (idAttr) { - animID = idAttr.as_string(); - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "animation") { - if (!anim) { - anim = new Animation; - anim->mName = animName; - pParent->mSubAnims.push_back(anim); - } - - // recurse into the sub-element - ReadAnimation(currentNode, anim); - } else if (currentName == "source") { - ReadSource(currentNode); - } else if (currentName == "sampler") { - std::string id; - if (XmlParser::getStdStrAttribute(currentNode, "id", id)) { - // have it read into a channel - ChannelMap::iterator newChannel = channels.insert(std::make_pair(id, AnimationChannel())).first; - ReadAnimationSampler(currentNode, newChannel->second); - } - } else if (currentName == "channel") { - std::string source_name, target; - XmlParser::getStdStrAttribute(currentNode, "source", source_name); - XmlParser::getStdStrAttribute(currentNode, "target", target); - if (source_name[0] == '#') { - source_name = source_name.substr(1, source_name.size() - 1); - } - ChannelMap::iterator cit = channels.find(source_name); - if (cit != channels.end()) { - cit->second.mTarget = target; - } - } - } - - // it turned out to have channels - add them - if (!channels.empty()) { - if (nullptr == anim) { - anim = new Animation; - anim->mName = animName; - pParent->mSubAnims.push_back(anim); - } - - for (const auto &channel : channels) { - anim->mChannels.push_back(channel.second); - } - - if (idAttr) { - mAnimationLibrary[animID] = anim; - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an animation sampler into the given anim channel -void ColladaParser::ReadAnimationSampler(XmlNode &node, Collada::AnimationChannel &pChannel) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "input") { - if (XmlParser::hasAttribute(currentNode, "semantic")) { - std::string semantic, sourceAttr; - XmlParser::getStdStrAttribute(currentNode, "semantic", semantic); - if (XmlParser::hasAttribute(currentNode, "source")) { - XmlParser::getStdStrAttribute(currentNode, "source", sourceAttr); - const char *source = sourceAttr.c_str(); - if (source[0] != '#') { - throw DeadlyImportError("Unsupported URL format"); - } - source++; - - if (semantic == "INPUT") { - pChannel.mSourceTimes = source; - } else if (semantic == "OUTPUT") { - pChannel.mSourceValues = source; - } else if (semantic == "IN_TANGENT") { - pChannel.mInTanValues = source; - } else if (semantic == "OUT_TANGENT") { - pChannel.mOutTanValues = source; - } else if (semantic == "INTERPOLATION") { - pChannel.mInterpolationValues = source; - } - } - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the skeleton controller library -void ColladaParser::ReadControllerLibrary(XmlNode &node) { - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName != "controller") { - continue; - } - std::string id; - if (XmlParser::getStdStrAttribute(currentNode, "id", id)) { - mControllerLibrary[id] = Controller(); - ReadController(currentNode, mControllerLibrary[id]); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a controller into the given mesh structure -void ColladaParser::ReadController(XmlNode &node, Collada::Controller &controller) { - // initial values - controller.mType = Skin; - controller.mMethod = Normalized; - - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "morph") { - controller.mType = Morph; - controller.mMeshId = currentNode.attribute("source").as_string(); - int methodIndex = currentNode.attribute("method").as_int(); - if (methodIndex > 0) { - std::string method; - XmlParser::getValueAsString(currentNode, method); - - if (method == "RELATIVE") { - controller.mMethod = Relative; - } - } - } else if (currentName == "skin") { - std::string id; - if (XmlParser::getStdStrAttribute(currentNode, "source", id)) { - controller.mMeshId = id.substr(1, id.size() - 1); - } - } else if (currentName == "bind_shape_matrix") { - std::string v; - XmlParser::getValueAsString(currentNode, v); - const char *content = v.c_str(); - for (unsigned int a = 0; a < 16; a++) { - SkipSpacesAndLineEnd(&content); - // read a number - content = fast_atoreal_move(content, controller.mBindShapeMatrix[a]); - // skip whitespace after it - SkipSpacesAndLineEnd(&content); - } - } else if (currentName == "source") { - ReadSource(currentNode); - } else if (currentName == "joints") { - ReadControllerJoints(currentNode, controller); - } else if (currentName == "vertex_weights") { - ReadControllerWeights(currentNode, controller); - } else if (currentName == "targets") { - for (XmlNode currentChildNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) { - const std::string ¤tChildName = currentChildNode.name(); - if (currentChildName == "input") { - const char *semantics = currentChildNode.attribute("semantic").as_string(); - const char *source = currentChildNode.attribute("source").as_string(); - if (strcmp(semantics, "MORPH_TARGET") == 0) { - controller.mMorphTarget = source + 1; - } else if (strcmp(semantics, "MORPH_WEIGHT") == 0) { - controller.mMorphWeight = source + 1; - } - } - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the joint definitions for the given controller -void ColladaParser::ReadControllerJoints(XmlNode &node, Collada::Controller &pController) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "input") { - const char *attrSemantic = currentNode.attribute("semantic").as_string(); - const char *attrSource = currentNode.attribute("source").as_string(); - if (attrSource[0] != '#') { - throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of data element"); - } - ++attrSource; - // parse source URL to corresponding source - if (strcmp(attrSemantic, "JOINT") == 0) { - pController.mJointNameSource = attrSource; - } else if (strcmp(attrSemantic, "INV_BIND_MATRIX") == 0) { - pController.mJointOffsetMatrixSource = attrSource; - } else { - throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in data element"); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the joint weights for the given controller -void ColladaParser::ReadControllerWeights(XmlNode &node, Collada::Controller &pController) { - // Read vertex count from attributes and resize the array accordingly - int vertexCount = 0; - XmlParser::getIntAttribute(node, "count", vertexCount); - pController.mWeightCounts.resize(vertexCount); - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "input") { - InputChannel channel; - - const char *attrSemantic = currentNode.attribute("semantic").as_string(); - const char *attrSource = currentNode.attribute("source").as_string(); - channel.mOffset = currentNode.attribute("offset").as_int(); - - // local URLS always start with a '#'. We don't support global URLs - if (attrSource[0] != '#') { - throw DeadlyImportError("Unsupported URL format in \"", attrSource, "\" in source attribute of data element"); - } - channel.mAccessor = attrSource + 1; - - // parse source URL to corresponding source - if (strcmp(attrSemantic, "JOINT") == 0) { - pController.mWeightInputJoints = channel; - } else if (strcmp(attrSemantic, "WEIGHT") == 0) { - pController.mWeightInputWeights = channel; - } else { - throw DeadlyImportError("Unknown semantic \"", attrSemantic, "\" in data element"); - } - } else if (currentName == "vcount" && vertexCount > 0) { - const char *text = currentNode.text().as_string(); - size_t numWeights = 0; - for (std::vector::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it) { - if (*text == 0) { - throw DeadlyImportError("Out of data while reading "); - } - - *it = strtoul10(text, &text); - numWeights += *it; - SkipSpacesAndLineEnd(&text); - } - // reserve weight count - pController.mWeights.resize(numWeights); - } else if (currentName == "v" && vertexCount > 0) { - // read JointIndex - WeightIndex pairs - std::string stdText; - XmlParser::getValueAsString(currentNode, stdText); - const char *text = stdText.c_str(); - for (std::vector>::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it) { - if (text == 0) { - throw DeadlyImportError("Out of data while reading "); - } - it->first = strtoul10(text, &text); - SkipSpacesAndLineEnd(&text); - if (*text == 0) { - throw DeadlyImportError("Out of data while reading "); - } - it->second = strtoul10(text, &text); - SkipSpacesAndLineEnd(&text); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the image library contents -void ColladaParser::ReadImageLibrary(XmlNode &node) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "image") { - std::string id; - if (XmlParser::getStdStrAttribute(currentNode, "id", id)) { - mImageLibrary[id] = Image(); - // read on from there - ReadImage(currentNode, mImageLibrary[id]); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an image entry into the given image -void ColladaParser::ReadImage(XmlNode &node, Collada::Image &pImage) { - for (XmlNode ¤tNode : node.children()) { - const std::string currentName = currentNode.name(); - if (currentName == "image") { - // Ignore - continue; - } else if (currentName == "init_from") { - if (mFormat == FV_1_4_n) { - // FIX: C4D exporter writes empty tags - if (!currentNode.empty()) { - // element content is filename - hopefully - const char *sz = currentNode.text().as_string(); - if (nullptr != sz) { - aiString filepath(sz); - UriDecodePath(filepath); - pImage.mFileName = filepath.C_Str(); - } - } - if (!pImage.mFileName.length()) { - pImage.mFileName = "unknown_texture"; - } - } - } else if (mFormat == FV_1_5_n) { - std::string value; - XmlNode refChild = currentNode.child("ref"); - XmlNode hexChild = currentNode.child("hex"); - if (refChild) { - // element content is filename - hopefully - if (XmlParser::getValueAsString(refChild, value)) { - aiString filepath(value); - UriDecodePath(filepath); - pImage.mFileName = filepath.C_Str(); - } - } else if (hexChild && !pImage.mFileName.length()) { - // embedded image. get format - pImage.mEmbeddedFormat = hexChild.attribute("format").as_string(); - if (pImage.mEmbeddedFormat.empty()) { - ASSIMP_LOG_WARN("Collada: Unknown image file format"); - } - - XmlParser::getValueAsString(hexChild, value); - const char *data = value.c_str(); - // hexadecimal-encoded binary octets. First of all, find the - // required buffer size to reserve enough storage. - const char *cur = data; - while (!IsSpaceOrNewLine(*cur)) { - ++cur; - } - - const unsigned int size = (unsigned int)(cur - data) * 2; - pImage.mImageData.resize(size); - for (unsigned int i = 0; i < size; ++i) { - pImage.mImageData[i] = HexOctetToDecimal(data + (i << 1)); - } - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the material library -void ColladaParser::ReadMaterialLibrary(XmlNode &node) { - std::map names; - for (XmlNode ¤tNode : node.children()) { - std::string id = currentNode.attribute("id").as_string(); - std::string name = currentNode.attribute("name").as_string(); - mMaterialLibrary[id] = Material(); - - if (!name.empty()) { - std::map::iterator it = names.find(name); - if (it != names.end()) { - std::ostringstream strStream; - strStream << ++it->second; - name.append(" " + strStream.str()); - } else { - names[name] = 0; - } - - mMaterialLibrary[id].mName = name; - } - - ReadMaterial(currentNode, mMaterialLibrary[id]); - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the light library -void ColladaParser::ReadLightLibrary(XmlNode &node) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "light") { - std::string id; - if (XmlParser::getStdStrAttribute(currentNode, "id", id)) { - ReadLight(currentNode, mLightLibrary[id] = Light()); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the camera library -void ColladaParser::ReadCameraLibrary(XmlNode &node) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "camera") { - std::string id; - if (!XmlParser::getStdStrAttribute(currentNode, "id", id)) { - continue; - } - - // create an entry and store it in the library under its ID - Camera &cam = mCameraLibrary[id]; - std::string name; - if (!XmlParser::getStdStrAttribute(currentNode, "name", name)) { - continue; - } - if (!name.empty()) { - cam.mName = name; - } - ReadCamera(currentNode, cam); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a material entry into the given material -void ColladaParser::ReadMaterial(XmlNode &node, Collada::Material &pMaterial) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "instance_effect") { - std::string url; - readUrlAttribute(currentNode, url); - pMaterial.mEffect = url; - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a light entry into the given light -void ColladaParser::ReadLight(XmlNode &node, Collada::Light &pLight) { - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - // TODO: Check the current technique and skip over unsupported extra techniques - - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "spot") { - pLight.mType = aiLightSource_SPOT; - } else if (currentName == "ambient") { - pLight.mType = aiLightSource_AMBIENT; - } else if (currentName == "directional") { - pLight.mType = aiLightSource_DIRECTIONAL; - } else if (currentName == "point") { - pLight.mType = aiLightSource_POINT; - } else if (currentName == "color") { - // text content contains 3 floats - std::string v; - XmlParser::getValueAsString(currentNode, v); - const char *content = v.c_str(); - - content = fast_atoreal_move(content, (ai_real &)pLight.mColor.r); - SkipSpacesAndLineEnd(&content); - - content = fast_atoreal_move(content, (ai_real &)pLight.mColor.g); - SkipSpacesAndLineEnd(&content); - - content = fast_atoreal_move(content, (ai_real &)pLight.mColor.b); - SkipSpacesAndLineEnd(&content); - } else if (currentName == "constant_attenuation") { - XmlParser::getValueAsFloat(currentNode, pLight.mAttConstant); - } else if (currentName == "linear_attenuation") { - XmlParser::getValueAsFloat(currentNode, pLight.mAttLinear); - } else if (currentName == "quadratic_attenuation") { - XmlParser::getValueAsFloat(currentNode, pLight.mAttQuadratic); - } else if (currentName == "falloff_angle") { - XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle); - } else if (currentName == "falloff_exponent") { - XmlParser::getValueAsFloat(currentNode, pLight.mFalloffExponent); - } - // FCOLLADA extensions - // ------------------------------------------------------- - else if (currentName == "outer_cone") { - XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle); - } else if (currentName == "penumbra_angle") { // this one is deprecated, now calculated using outer_cone - XmlParser::getValueAsFloat(currentNode, pLight.mPenumbraAngle); - } else if (currentName == "intensity") { - XmlParser::getValueAsFloat(currentNode, pLight.mIntensity); - } - else if (currentName == "falloff") { - XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle); - } else if (currentName == "hotspot_beam") { - XmlParser::getValueAsFloat(currentNode, pLight.mFalloffAngle); - } - // OpenCOLLADA extensions - // ------------------------------------------------------- - else if (currentName == "decay_falloff") { - XmlParser::getValueAsFloat(currentNode, pLight.mOuterAngle); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a camera entry into the given light -void ColladaParser::ReadCamera(XmlNode &node, Collada::Camera &camera) { - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "orthographic") { - camera.mOrtho = true; - } else if (currentName == "xfov" || currentName == "xmag") { - XmlParser::getValueAsFloat(currentNode, camera.mHorFov); - } else if (currentName == "yfov" || currentName == "ymag") { - XmlParser::getValueAsFloat(currentNode, camera.mVerFov); - } else if (currentName == "aspect_ratio") { - XmlParser::getValueAsFloat(currentNode, camera.mAspect); - } else if (currentName == "znear") { - XmlParser::getValueAsFloat(currentNode, camera.mZNear); - } else if (currentName == "zfar") { - XmlParser::getValueAsFloat(currentNode, camera.mZFar); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the effect library -void ColladaParser::ReadEffectLibrary(XmlNode &node) { - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "effect") { - // read ID. Do I have to repeat my ranting about "optional" attributes? - std::string id; - XmlParser::getStdStrAttribute(currentNode, "id", id); - - // create an entry and store it in the library under its ID - mEffectLibrary[id] = Effect(); - - // read on from there - ReadEffect(currentNode, mEffectLibrary[id]); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an effect entry into the given effect -void ColladaParser::ReadEffect(XmlNode &node, Collada::Effect &pEffect) { - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "profile_COMMON") { - ReadEffectProfileCommon(currentNode, pEffect); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an COMMON effect profile -void ColladaParser::ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect) { - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string currentName = currentNode.name(); - if (currentName == "newparam") { - // save ID - std::string sid = currentNode.attribute("sid").as_string(); - pEffect.mParams[sid] = EffectParam(); - ReadEffectParam(currentNode, pEffect.mParams[sid]); - } else if (currentName == "technique" || currentName == "extra") { - // just syntactic sugar - } else if (mFormat == FV_1_4_n && currentName == "image") { - // read ID. Another entry which is "optional" by design but obligatory in reality - std::string id = currentNode.attribute("id").as_string(); - - // create an entry and store it in the library under its ID - mImageLibrary[id] = Image(); - - // read on from there - ReadImage(currentNode, mImageLibrary[id]); - } else if (currentName == "phong") - pEffect.mShadeType = Shade_Phong; - else if (currentName == "constant") - pEffect.mShadeType = Shade_Constant; - else if (currentName == "lambert") - pEffect.mShadeType = Shade_Lambert; - else if (currentName == "blinn") - pEffect.mShadeType = Shade_Blinn; - - /* Color + texture properties */ - else if (currentName == "emission") - ReadEffectColor(currentNode, pEffect.mEmissive, pEffect.mTexEmissive); - else if (currentName == "ambient") - ReadEffectColor(currentNode, pEffect.mAmbient, pEffect.mTexAmbient); - else if (currentName == "diffuse") - ReadEffectColor(currentNode, pEffect.mDiffuse, pEffect.mTexDiffuse); - else if (currentName == "specular") - ReadEffectColor(currentNode, pEffect.mSpecular, pEffect.mTexSpecular); - else if (currentName == "reflective") { - ReadEffectColor(currentNode, pEffect.mReflective, pEffect.mTexReflective); - } else if (currentName == "transparent") { - pEffect.mHasTransparency = true; - const char *opaque = currentNode.attribute("opaque").as_string(); - //const char *opaque = mReader->getAttributeValueSafe("opaque"); - - if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) { - pEffect.mRGBTransparency = true; - } - - // In RGB_ZERO mode, the transparency is interpreted in reverse, go figure... - if (::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "A_ZERO") == 0) { - pEffect.mInvertTransparency = true; - } - - ReadEffectColor(currentNode, pEffect.mTransparent, pEffect.mTexTransparent); - } else if (currentName == "shininess") - ReadEffectFloat(currentNode, pEffect.mShininess); - else if (currentName == "reflectivity") - ReadEffectFloat(currentNode, pEffect.mReflectivity); - - /* Single scalar properties */ - else if (currentName == "transparency") - ReadEffectFloat(currentNode, pEffect.mTransparency); - else if (currentName == "index_of_refraction") - ReadEffectFloat(currentNode, pEffect.mRefractIndex); - - // GOOGLEEARTH/OKINO extensions - // ------------------------------------------------------- - else if (currentName == "double_sided") - XmlParser::getValueAsBool(currentNode, pEffect.mDoubleSided); - - // FCOLLADA extensions - // ------------------------------------------------------- - else if (currentName == "bump") { - aiColor4D dummy; - ReadEffectColor(currentNode, dummy, pEffect.mTexBump); - } - - // MAX3D extensions - // ------------------------------------------------------- - else if (currentName == "wireframe") { - XmlParser::getValueAsBool(currentNode, pEffect.mWireframe); - } else if (currentName == "faceted") { - XmlParser::getValueAsBool(currentNode, pEffect.mFaceted); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Read texture wrapping + UV transform settings from a profile==Maya chunk -void ColladaParser::ReadSamplerProperties(XmlNode &node, Sampler &out) { - if (node.empty()) { - return; - } - - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - // MAYA extensions - // ------------------------------------------------------- - if (currentName == "wrapU") { - XmlParser::getValueAsBool(currentNode, out.mWrapU); - } else if (currentName == "wrapV") { - XmlParser::getValueAsBool(currentNode, out.mWrapV); - } else if (currentName == "mirrorU") { - XmlParser::getValueAsBool(currentNode, out.mMirrorU); - } else if (currentName == "mirrorV") { - XmlParser::getValueAsBool(currentNode, out.mMirrorV); - } else if (currentName == "repeatU") { - XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.x); - } else if (currentName == "repeatV") { - XmlParser::getValueAsFloat(currentNode, out.mTransform.mScaling.y); - } else if (currentName == "offsetU") { - XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.x); - } else if (currentName == "offsetV") { - XmlParser::getValueAsFloat(currentNode, out.mTransform.mTranslation.y); - } else if (currentName == "rotateUV") { - XmlParser::getValueAsFloat(currentNode, out.mTransform.mRotation); - } else if (currentName == "blend_mode") { - std::string v; - XmlParser::getValueAsString(currentNode, v); - const char *sz = v.c_str(); - // http://www.feelingsoftware.com/content/view/55/72/lang,en/ - // NONE, OVER, IN, OUT, ADD, SUBTRACT, MULTIPLY, DIFFERENCE, LIGHTEN, DARKEN, SATURATE, DESATURATE and ILLUMINATE - if (0 == ASSIMP_strincmp(sz, "ADD", 3)) - out.mOp = aiTextureOp_Add; - else if (0 == ASSIMP_strincmp(sz, "SUBTRACT", 8)) - out.mOp = aiTextureOp_Subtract; - else if (0 == ASSIMP_strincmp(sz, "MULTIPLY", 8)) - out.mOp = aiTextureOp_Multiply; - else { - ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode"); - } - } - // OKINO extensions - // ------------------------------------------------------- - else if (currentName == "weighting") { - XmlParser::getValueAsFloat(currentNode, out.mWeighting); - } else if (currentName == "mix_with_previous_layer") { - XmlParser::getValueAsFloat(currentNode, out.mMixWithPrevious); - } - // MAX3D extensions - // ------------------------------------------------------- - else if (currentName == "amount") { - XmlParser::getValueAsFloat(currentNode, out.mWeighting); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an effect entry containing a color or a texture defining that color -void ColladaParser::ReadEffectColor(XmlNode &node, aiColor4D &pColor, Sampler &pSampler) { - if (node.empty()) { - return; - } - - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "color") { - // text content contains 4 floats - std::string v; - XmlParser::getValueAsString(currentNode, v); - const char *content = v.c_str(); - - content = fast_atoreal_move(content, (ai_real &)pColor.r); - SkipSpacesAndLineEnd(&content); - - content = fast_atoreal_move(content, (ai_real &)pColor.g); - SkipSpacesAndLineEnd(&content); - - content = fast_atoreal_move(content, (ai_real &)pColor.b); - SkipSpacesAndLineEnd(&content); - - content = fast_atoreal_move(content, (ai_real &)pColor.a); - SkipSpacesAndLineEnd(&content); - } else if (currentName == "texture") { - // get name of source texture/sampler - XmlParser::getStdStrAttribute(currentNode, "texture", pSampler.mName); - - // get name of UV source channel. Specification demands it to be there, but some exporters - // don't write it. It will be the default UV channel in case it's missing. - XmlParser::getStdStrAttribute(currentNode, "texcoord", pSampler.mUVChannel); - - // as we've read texture, the color needs to be 1,1,1,1 - pColor = aiColor4D(1.f, 1.f, 1.f, 1.f); - } else if (currentName == "technique") { - std::string profile; - XmlParser::getStdStrAttribute(currentNode, "profile", profile); - - // Some extensions are quite useful ... ReadSamplerProperties processes - // several extensions in MAYA, OKINO and MAX3D profiles. - if (!::strcmp(profile.c_str(), "MAYA") || !::strcmp(profile.c_str(), "MAX3D") || !::strcmp(profile.c_str(), "OKINO")) { - // get more information on this sampler - ReadSamplerProperties(currentNode, pSampler); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an effect entry containing a float -void ColladaParser::ReadEffectFloat(XmlNode &node, ai_real &pFloat) { - pFloat = 0.f; - XmlNode floatNode = node.child("float"); - if (floatNode.empty()) { - return; - } - XmlParser::getValueAsFloat(floatNode, pFloat); -} - -// ------------------------------------------------------------------------------------------------ -// Reads an effect parameter specification of any kind -void ColladaParser::ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam) { - if (node.empty()) { - return; - } - - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "surface") { - // image ID given inside tags - XmlNode initNode = currentNode.child("init_from"); - if (initNode) { - std::string v; - XmlParser::getValueAsString(initNode, v); - pParam.mType = Param_Surface; - pParam.mReference = v.c_str(); - } - } else if (currentName == "sampler2D" && (FV_1_4_n == mFormat || FV_1_3_n == mFormat)) { - // surface ID is given inside tags - const char *content = currentNode.value(); - pParam.mType = Param_Sampler; - pParam.mReference = content; - } else if (currentName == "sampler2D") { - // surface ID is given inside tags - std::string url; - XmlParser::getStdStrAttribute(currentNode, "url", url); - if (url[0] != '#') { - throw DeadlyImportError("Unsupported URL format in instance_image"); - } - pParam.mType = Param_Sampler; - pParam.mReference = url.c_str() + 1; - } else if (currentName == "source") { - const char *source = currentNode.child_value(); - if (nullptr != source) { - pParam.mReference = source; - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the geometry library contents -void ColladaParser::ReadGeometryLibrary(XmlNode &node) { - if (node.empty()) { - return; - } - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "geometry") { - // read ID. Another entry which is "optional" by design but obligatory in reality - - std::string id; - XmlParser::getStdStrAttribute(currentNode, "id", id); - // create a mesh and store it in the library under its (resolved) ID - // Skip and warn if ID is not unique - if (mMeshLibrary.find(id) == mMeshLibrary.cend()) { - std::unique_ptr mesh(new Mesh(id)); - - XmlParser::getStdStrAttribute(currentNode, "name", mesh->mName); - - // read on from there - ReadGeometry(currentNode, *mesh); - // Read successfully, add to library - mMeshLibrary.insert({ id, mesh.release() }); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a geometry from the geometry library. -void ColladaParser::ReadGeometry(XmlNode &node, Collada::Mesh &pMesh) { - if (node.empty()) { - return; - } - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "mesh") { - ReadMesh(currentNode, pMesh); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a mesh from the geometry library -void ColladaParser::ReadMesh(XmlNode &node, Mesh &pMesh) { - if (node.empty()) { - return; - } - - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "source") { - ReadSource(currentNode); - } else if (currentName == "vertices") { - ReadVertexData(currentNode, pMesh); - } else if (currentName == "triangles" || currentName == "lines" || currentName == "linestrips" || - currentName == "polygons" || currentName == "polylist" || currentName == "trifans" || - currentName == "tristrips") { - ReadIndexData(currentNode, pMesh); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a source element -void ColladaParser::ReadSource(XmlNode &node) { - if (node.empty()) { - return; - } - - std::string sourceID; - XmlParser::getStdStrAttribute(node, "id", sourceID); - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "float_array" || currentName == "IDREF_array" || currentName == "Name_array") { - ReadDataArray(currentNode); - } else if (currentName == "technique_common") { - XmlNode technique = currentNode.child("accessor"); - if (!technique.empty()) { - ReadAccessor(technique, sourceID); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a data array holding a number of floats, and stores it in the global library -void ColladaParser::ReadDataArray(XmlNode &node) { - std::string name = node.name(); - bool isStringArray = (name == "IDREF_array" || name == "Name_array"); - - // read attributes - std::string id; - XmlParser::getStdStrAttribute(node, "id", id); - unsigned int count = 0; - XmlParser::getUIntAttribute(node, "count", count); - std::string v; - XmlParser::getValueAsString(node, v); - v = ai_trim(v); - const char *content = v.c_str(); - - // read values and store inside an array in the data library - mDataLibrary[id] = Data(); - Data &data = mDataLibrary[id]; - data.mIsStringArray = isStringArray; - - // some exporters write empty data arrays, but we need to conserve them anyways because others might reference them - if (content) { - if (isStringArray) { - data.mStrings.reserve(count); - std::string s; - - for (unsigned int a = 0; a < count; a++) { - if (*content == 0) { - throw DeadlyImportError("Expected more values while reading IDREF_array contents."); - } - - s.clear(); - while (!IsSpaceOrNewLine(*content)) - s += *content++; - data.mStrings.push_back(s); - - SkipSpacesAndLineEnd(&content); - } - } else { - data.mValues.reserve(count); - - for (unsigned int a = 0; a < count; a++) { - if (*content == 0) { - throw DeadlyImportError("Expected more values while reading float_array contents."); - } - - // read a number - ai_real value; - content = fast_atoreal_move(content, value); - data.mValues.push_back(value); - // skip whitespace after it - SkipSpacesAndLineEnd(&content); - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads an accessor and stores it in the global library -void ColladaParser::ReadAccessor(XmlNode &node, const std::string &pID) { - // read accessor attributes - std::string source; - XmlParser::getStdStrAttribute(node, "source", source); - if (source[0] != '#') { - throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of element."); - } - int count = 0; - XmlParser::getIntAttribute(node, "count", count); - - unsigned int offset = 0; - if (XmlParser::hasAttribute(node, "offset")) { - XmlParser::getUIntAttribute(node, "offset", offset); - } - unsigned int stride = 1; - if (XmlParser::hasAttribute(node, "stride")) { - XmlParser::getUIntAttribute(node, "stride", stride); - } - // store in the library under the given ID - mAccessorLibrary[pID] = Accessor(); - Accessor &acc = mAccessorLibrary[pID]; - acc.mCount = count; - acc.mOffset = offset; - acc.mStride = stride; - acc.mSource = source.c_str() + 1; // ignore the leading '#' - acc.mSize = 0; // gets incremented with every param - - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "param") { - // read data param - std::string name; - if (XmlParser::hasAttribute(currentNode, "name")) { - XmlParser::getStdStrAttribute(currentNode, "name", name); - - // analyse for common type components and store it's sub-offset in the corresponding field - - // Cartesian coordinates - if (name == "X") - acc.mSubOffset[0] = acc.mParams.size(); - else if (name == "Y") - acc.mSubOffset[1] = acc.mParams.size(); - else if (name == "Z") - acc.mSubOffset[2] = acc.mParams.size(); - - /* RGBA colors */ - else if (name == "R") - acc.mSubOffset[0] = acc.mParams.size(); - else if (name == "G") - acc.mSubOffset[1] = acc.mParams.size(); - else if (name == "B") - acc.mSubOffset[2] = acc.mParams.size(); - else if (name == "A") - acc.mSubOffset[3] = acc.mParams.size(); - - /* UVWQ (STPQ) texture coordinates */ - else if (name == "S") - acc.mSubOffset[0] = acc.mParams.size(); - else if (name == "T") - acc.mSubOffset[1] = acc.mParams.size(); - else if (name == "P") - acc.mSubOffset[2] = acc.mParams.size(); - /* Generic extra data, interpreted as UV data, too*/ - else if (name == "U") - acc.mSubOffset[0] = acc.mParams.size(); - else if (name == "V") - acc.mSubOffset[1] = acc.mParams.size(); - } - if (XmlParser::hasAttribute(currentNode, "type")) { - // read data type - // TODO: (thom) I don't have a spec here at work. Check if there are other multi-value types - // which should be tested for here. - std::string type; - - XmlParser::getStdStrAttribute(currentNode, "type", type); - if (type == "float4x4") - acc.mSize += 16; - else - acc.mSize += 1; - } - - acc.mParams.push_back(name); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads input declarations of per-vertex mesh data into the given mesh -void ColladaParser::ReadVertexData(XmlNode &node, Mesh &pMesh) { - // extract the ID of the element. Not that we care, but to catch strange referencing schemes we should warn about - XmlParser::getStdStrAttribute(node, "id", pMesh.mVertexID); - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "input") { - ReadInputChannel(currentNode, pMesh.mPerVertexData); - } else { - throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag "); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads input declarations of per-index mesh data into the given mesh -void ColladaParser::ReadIndexData(XmlNode &node, Mesh &pMesh) { - std::vector vcount; - std::vector perIndexData; - - unsigned int numPrimitives = 0; - XmlParser::getUIntAttribute(node, "count", numPrimitives); - // read primitive count from the attribute - //int attrCount = GetAttribute("count"); - //size_t numPrimitives = (size_t)mReader->getAttributeValueAsInt(attrCount); - // some mesh types (e.g. tristrips) don't specify primitive count upfront, - // so we need to sum up the actual number of primitives while we read the

-tags - size_t actualPrimitives = 0; - SubMesh subgroup; - if (XmlParser::hasAttribute(node, "material")) { - XmlParser::getStdStrAttribute(node, "material", subgroup.mMaterial); - } - - // distinguish between polys and triangles - std::string elementName = node.name(); - PrimitiveType primType = Prim_Invalid; - if (elementName == "lines") - primType = Prim_Lines; - else if (elementName == "linestrips") - primType = Prim_LineStrip; - else if (elementName == "polygons") - primType = Prim_Polygon; - else if (elementName == "polylist") - primType = Prim_Polylist; - else if (elementName == "triangles") - primType = Prim_Triangles; - else if (elementName == "trifans") - primType = Prim_TriFans; - else if (elementName == "tristrips") - primType = Prim_TriStrips; - - ai_assert(primType != Prim_Invalid); - - // also a number of elements, but in addition a

primitive collection and probably index counts for all primitives - XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode); - XmlNode currentNode; - while (xmlIt.getNext(currentNode)) { - const std::string ¤tName = currentNode.name(); - if (currentName == "input") { - ReadInputChannel(currentNode, perIndexData); - } else if (currentName == "vcount") { - if (!currentNode.empty()) { - if (numPrimitives) // It is possible to define a mesh without any primitives - { - // case - specifies the number of indices for each polygon - std::string v; - XmlParser::getValueAsString(currentNode, v); - const char *content = v.c_str(); - vcount.reserve(numPrimitives); - for (unsigned int a = 0; a < numPrimitives; a++) { - if (*content == 0) { - throw DeadlyImportError("Expected more values while reading contents."); - } - // read a number - vcount.push_back((size_t)strtoul10(content, &content)); - // skip whitespace after it - SkipSpacesAndLineEnd(&content); - } - } - } - } else if (currentName == "p") { - if (!currentNode.empty()) { - // now here the actual fun starts - these are the indices to construct the mesh data from - actualPrimitives += ReadPrimitives(currentNode, pMesh, perIndexData, numPrimitives, vcount, primType); - } - } else if (currentName == "extra") { - // skip - } else if (currentName == "ph") { - // skip - } else { - throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <", elementName, ">"); - } - } - -#ifdef ASSIMP_BUILD_DEBUG - if (primType != Prim_TriFans && primType != Prim_TriStrips && primType != Prim_LineStrip && - primType != Prim_Lines) { // this is ONLY to workaround a bug in SketchUp 15.3.331 where it writes the wrong 'count' when it writes out the 'lines'. - ai_assert(actualPrimitives == numPrimitives); - } -#endif - - // only when we're done reading all

tags (and thus know the final vertex count) can we commit the submesh - subgroup.mNumFaces = actualPrimitives; - pMesh.mSubMeshes.push_back(subgroup); -} - -// ------------------------------------------------------------------------------------------------ -// Reads a single input channel element and stores it in the given array, if valid -void ColladaParser::ReadInputChannel(XmlNode &node, std::vector &poChannels) { - InputChannel channel; - - // read semantic - std::string semantic; - XmlParser::getStdStrAttribute(node, "semantic", semantic); - channel.mType = GetTypeForSemantic(semantic); - - // read source - std::string source; - XmlParser::getStdStrAttribute(node, "source", source); - if (source[0] != '#') { - throw DeadlyImportError("Unknown reference format in url \"", source, "\" in source attribute of element."); - } - channel.mAccessor = source.c_str() + 1; // skipping the leading #, hopefully the remaining text is the accessor ID only - - // read index offset, if per-index - if (XmlParser::hasAttribute(node, "offset")) { - XmlParser::getUIntAttribute(node, "offset", (unsigned int &)channel.mOffset); - } - - // read set if texture coordinates - if (channel.mType == IT_Texcoord || channel.mType == IT_Color) { - unsigned int attrSet = 0; - if (XmlParser::getUIntAttribute(node, "set", attrSet)) - channel.mIndex = attrSet; - } - - // store, if valid type - if (channel.mType != IT_Invalid) - poChannels.push_back(channel); -} - -// ------------------------------------------------------------------------------------------------ -// Reads a

primitive index list and assembles the mesh data into the given mesh -size_t ColladaParser::ReadPrimitives(XmlNode &node, Mesh &pMesh, std::vector &pPerIndexChannels, - size_t pNumPrimitives, const std::vector &pVCount, PrimitiveType pPrimType) { - // determine number of indices coming per vertex - // find the offset index for all per-vertex channels - size_t numOffsets = 1; - size_t perVertexOffset = SIZE_MAX; // invalid value - for (const InputChannel &channel : pPerIndexChannels) { - numOffsets = std::max(numOffsets, channel.mOffset + 1); - if (channel.mType == IT_Vertex) - perVertexOffset = channel.mOffset; - } - - // determine the expected number of indices - size_t expectedPointCount = 0; - switch (pPrimType) { - case Prim_Polylist: { - for (size_t i : pVCount) - expectedPointCount += i; - break; - } - case Prim_Lines: - expectedPointCount = 2 * pNumPrimitives; - break; - case Prim_Triangles: - expectedPointCount = 3 * pNumPrimitives; - break; - default: - // other primitive types don't state the index count upfront... we need to guess - break; - } - - // and read all indices into a temporary array - std::vector indices; - if (expectedPointCount > 0) { - indices.reserve(expectedPointCount * numOffsets); - } - - // It is possible to not contain any indices - if (pNumPrimitives > 0) { - std::string v; - XmlParser::getValueAsString(node, v); - const char *content = v.c_str(); - SkipSpacesAndLineEnd(&content); - while (*content != 0) { - // read a value. - // Hack: (thom) Some exporters put negative indices sometimes. We just try to carry on anyways. - int value = std::max(0, strtol10(content, &content)); - indices.push_back(size_t(value)); - // skip whitespace after it - SkipSpacesAndLineEnd(&content); - } - } - - // complain if the index count doesn't fit - if (expectedPointCount > 0 && indices.size() != expectedPointCount * numOffsets) { - if (pPrimType == Prim_Lines) { - // HACK: We just fix this number since SketchUp 15.3.331 writes the wrong 'count' for 'lines' - ReportWarning("Expected different index count in

element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets); - pNumPrimitives = (indices.size() / numOffsets) / 2; - } else { - throw DeadlyImportError("Expected different index count in

element."); - } - } else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0) { - throw DeadlyImportError("Expected different index count in

element."); - } - - // find the data for all sources - for (std::vector::iterator it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) { - InputChannel &input = *it; - if (input.mResolved) { - continue; - } - - // find accessor - input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor); - // resolve accessor's data pointer as well, if necessary - const Accessor *acc = input.mResolved; - if (!acc->mData) { - acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource); - } - } - // and the same for the per-index channels - for (std::vector::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) { - InputChannel &input = *it; - if (input.mResolved) { - continue; - } - - // ignore vertex pointer, it doesn't refer to an accessor - if (input.mType == IT_Vertex) { - // warn if the vertex channel does not refer to the element in the same mesh - if (input.mAccessor != pMesh.mVertexID) { - throw DeadlyImportError("Unsupported vertex referencing scheme."); - } - continue; - } - - // find accessor - input.mResolved = &ResolveLibraryReference(mAccessorLibrary, input.mAccessor); - // resolve accessor's data pointer as well, if necessary - const Accessor *acc = input.mResolved; - if (!acc->mData) { - acc->mData = &ResolveLibraryReference(mDataLibrary, acc->mSource); - } - } - - // For continued primitives, the given count does not come all in one

, but only one primitive per

- size_t numPrimitives = pNumPrimitives; - if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon) - numPrimitives = 1; - // For continued primitives, the given count is actually the number of

's inside the parent tag - if (pPrimType == Prim_TriStrips) { - size_t numberOfVertices = indices.size() / numOffsets; - numPrimitives = numberOfVertices - 2; - } - if (pPrimType == Prim_LineStrip) { - size_t numberOfVertices = indices.size() / numOffsets; - numPrimitives = numberOfVertices - 1; - } - - pMesh.mFaceSize.reserve(numPrimitives); - pMesh.mFacePosIndices.reserve(indices.size() / numOffsets); - - size_t polylistStartVertex = 0; - for (size_t currentPrimitive = 0; currentPrimitive < numPrimitives; currentPrimitive++) { - // determine number of points for this primitive - size_t numPoints = 0; - switch (pPrimType) { - case Prim_Lines: - numPoints = 2; - for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) - CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - break; - case Prim_LineStrip: - numPoints = 2; - for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) - CopyVertex(currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - break; - case Prim_Triangles: - numPoints = 3; - for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) - CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - break; - case Prim_TriStrips: - numPoints = 3; - ReadPrimTriStrips(numOffsets, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - break; - case Prim_Polylist: - numPoints = pVCount[currentPrimitive]; - for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) - CopyVertex(polylistStartVertex + currentVertex, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, 0, indices); - polylistStartVertex += numPoints; - break; - case Prim_TriFans: - case Prim_Polygon: - numPoints = indices.size() / numOffsets; - for (size_t currentVertex = 0; currentVertex < numPoints; currentVertex++) - CopyVertex(currentVertex, numOffsets, numPoints, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - break; - default: - // LineStrip is not supported due to expected index unmangling - throw DeadlyImportError("Unsupported primitive type."); - break; - } - - // store the face size to later reconstruct the face from - pMesh.mFaceSize.push_back(numPoints); - } - - // if I ever get my hands on that guy who invented this steaming pile of indirection... - return numPrimitives; -} - -///@note This function won't work correctly if both PerIndex and PerVertex channels have same channels. -///For example if TEXCOORD present in both and tags this function will create wrong uv coordinates. -///It's not clear from COLLADA documentation is this allowed or not. For now only exporter fixed to avoid such behavior -void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh &pMesh, - std::vector &pPerIndexChannels, size_t currentPrimitive, const std::vector &indices) { - // calculate the base offset of the vertex whose attributes we ant to copy - size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets; - - // don't overrun the boundaries of the index list - ai_assert((baseOffset + numOffsets - 1) < indices.size()); - - // extract per-vertex channels using the global per-vertex offset - for (std::vector::iterator it = pMesh.mPerVertexData.begin(); it != pMesh.mPerVertexData.end(); ++it) { - ExtractDataObjectFromChannel(*it, indices[baseOffset + perVertexOffset], pMesh); - } - // and extract per-index channels using there specified offset - for (std::vector::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it) { - ExtractDataObjectFromChannel(*it, indices[baseOffset + it->mOffset], pMesh); - } - - // store the vertex-data index for later assignment of bone vertex weights - pMesh.mFacePosIndices.push_back(indices[baseOffset + perVertexOffset]); -} - -void ColladaParser::ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Mesh &pMesh, std::vector &pPerIndexChannels, - size_t currentPrimitive, const std::vector &indices) { - if (currentPrimitive % 2 != 0) { - //odd tristrip triangles need their indices mangled, to preserve winding direction - CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - } else { //for non tristrips or even tristrip triangles - CopyVertex(0, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - CopyVertex(1, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - CopyVertex(2, numOffsets, 1, perVertexOffset, pMesh, pPerIndexChannels, currentPrimitive, indices); - } -} - -// ------------------------------------------------------------------------------------------------ -// Extracts a single object from an input channel and stores it in the appropriate mesh data array -void ColladaParser::ExtractDataObjectFromChannel(const InputChannel &pInput, size_t pLocalIndex, Mesh &pMesh) { - // ignore vertex referrer - we handle them that separate - if (pInput.mType == IT_Vertex) { - return; - } - - const Accessor &acc = *pInput.mResolved; - if (pLocalIndex >= acc.mCount) { - throw DeadlyImportError("Invalid data index (", pLocalIndex, "/", acc.mCount, ") in primitive specification"); - } - - // get a pointer to the start of the data object referred to by the accessor and the local index - const ai_real *dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex * acc.mStride; - - // assemble according to the accessors component sub-offset list. We don't care, yet, - // what kind of object exactly we're extracting here - ai_real obj[4]; - for (size_t c = 0; c < 4; ++c) { - obj[c] = dataObject[acc.mSubOffset[c]]; - } - - // now we reinterpret it according to the type we're reading here - switch (pInput.mType) { - case IT_Position: // ignore all position streams except 0 - there can be only one position - if (pInput.mIndex == 0) { - pMesh.mPositions.push_back(aiVector3D(obj[0], obj[1], obj[2])); - } else { - ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported"); - } - break; - case IT_Normal: - // pad to current vertex count if necessary - if (pMesh.mNormals.size() < pMesh.mPositions.size() - 1) - pMesh.mNormals.insert(pMesh.mNormals.end(), pMesh.mPositions.size() - pMesh.mNormals.size() - 1, aiVector3D(0, 1, 0)); - - // ignore all normal streams except 0 - there can be only one normal - if (pInput.mIndex == 0) { - pMesh.mNormals.push_back(aiVector3D(obj[0], obj[1], obj[2])); - } else { - ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported"); - } - break; - case IT_Tangent: - // pad to current vertex count if necessary - if (pMesh.mTangents.size() < pMesh.mPositions.size() - 1) - pMesh.mTangents.insert(pMesh.mTangents.end(), pMesh.mPositions.size() - pMesh.mTangents.size() - 1, aiVector3D(1, 0, 0)); - - // ignore all tangent streams except 0 - there can be only one tangent - if (pInput.mIndex == 0) { - pMesh.mTangents.push_back(aiVector3D(obj[0], obj[1], obj[2])); - } else { - ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported"); - } - break; - case IT_Bitangent: - // pad to current vertex count if necessary - if (pMesh.mBitangents.size() < pMesh.mPositions.size() - 1) { - pMesh.mBitangents.insert(pMesh.mBitangents.end(), pMesh.mPositions.size() - pMesh.mBitangents.size() - 1, aiVector3D(0, 0, 1)); - } - - // ignore all bitangent streams except 0 - there can be only one bitangent - if (pInput.mIndex == 0) { - pMesh.mBitangents.push_back(aiVector3D(obj[0], obj[1], obj[2])); - } else { - ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported"); - } - break; - case IT_Texcoord: - // up to 4 texture coord sets are fine, ignore the others - if (pInput.mIndex < AI_MAX_NUMBER_OF_TEXTURECOORDS) { - // pad to current vertex count if necessary - if (pMesh.mTexCoords[pInput.mIndex].size() < pMesh.mPositions.size() - 1) - pMesh.mTexCoords[pInput.mIndex].insert(pMesh.mTexCoords[pInput.mIndex].end(), - pMesh.mPositions.size() - pMesh.mTexCoords[pInput.mIndex].size() - 1, aiVector3D(0, 0, 0)); - - pMesh.mTexCoords[pInput.mIndex].push_back(aiVector3D(obj[0], obj[1], obj[2])); - if (0 != acc.mSubOffset[2] || 0 != acc.mSubOffset[3]) { - pMesh.mNumUVComponents[pInput.mIndex] = 3; - } - } else { - ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping."); - } - break; - case IT_Color: - // up to 4 color sets are fine, ignore the others - if (pInput.mIndex < AI_MAX_NUMBER_OF_COLOR_SETS) { - // pad to current vertex count if necessary - if (pMesh.mColors[pInput.mIndex].size() < pMesh.mPositions.size() - 1) - pMesh.mColors[pInput.mIndex].insert(pMesh.mColors[pInput.mIndex].end(), - pMesh.mPositions.size() - pMesh.mColors[pInput.mIndex].size() - 1, aiColor4D(0, 0, 0, 1)); - - aiColor4D result(0, 0, 0, 1); - for (size_t i = 0; i < pInput.mResolved->mSize; ++i) { - result[static_cast(i)] = obj[pInput.mResolved->mSubOffset[i]]; - } - pMesh.mColors[pInput.mIndex].push_back(result); - } else { - ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping."); - } - - break; - default: - // IT_Invalid and IT_Vertex - ai_assert(false && "shouldn't ever get here"); - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads the library of node hierarchies and scene parts -void ColladaParser::ReadSceneLibrary(XmlNode &node) { - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "visual_scene") { - // read ID. Is optional according to the spec, but how on earth should a scene_instance refer to it then? - std::string id; - XmlParser::getStdStrAttribute(currentNode, "id", id); - - // read name if given. - std::string attrName = "Scene"; - if (XmlParser::hasAttribute(currentNode, "name")) { - XmlParser::getStdStrAttribute(currentNode, "name", attrName); - } - - // create a node and store it in the library under its ID - Node *sceneNode = new Node; - sceneNode->mID = id; - sceneNode->mName = attrName; - mNodeLibrary[sceneNode->mID] = sceneNode; - - ReadSceneNode(currentNode, sceneNode); - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a scene node's contents including children and stores it in the given node -void ColladaParser::ReadSceneNode(XmlNode &node, Node *pNode) { - // quit immediately on elements - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "node") { - Node *child = new Node; - if (XmlParser::hasAttribute(currentNode, "id")) { - XmlParser::getStdStrAttribute(currentNode, "id", child->mID); - } - if (XmlParser::hasAttribute(currentNode, "sid")) { - XmlParser::getStdStrAttribute(currentNode, "id", child->mSID); - } - if (XmlParser::hasAttribute(currentNode, "name")) { - XmlParser::getStdStrAttribute(currentNode, "name", child->mName); - } - if (pNode) { - pNode->mChildren.push_back(child); - child->mParent = pNode; - } else { - // no parent node given, probably called from element. - // create new node in node library - mNodeLibrary[child->mID] = child; - } - - // read on recursively from there - ReadSceneNode(currentNode, child); - continue; - } else if (!pNode) { - // For any further stuff we need a valid node to work on - continue; - } - if (currentName == "lookat") { - ReadNodeTransformation(currentNode, pNode, TF_LOOKAT); - } else if (currentName == "matrix") { - ReadNodeTransformation(currentNode, pNode, TF_MATRIX); - } else if (currentName == "rotate") { - ReadNodeTransformation(currentNode, pNode, TF_ROTATE); - } else if (currentName == "scale") { - ReadNodeTransformation(currentNode, pNode, TF_SCALE); - } else if (currentName == "skew") { - ReadNodeTransformation(currentNode, pNode, TF_SKEW); - } else if (currentName == "translate") { - ReadNodeTransformation(currentNode, pNode, TF_TRANSLATE); - } else if (currentName == "render" && pNode->mParent == nullptr && 0 == pNode->mPrimaryCamera.length()) { - // ... scene evaluation or, in other words, postprocessing pipeline, - // or, again in other words, a turing-complete description how to - // render a Collada scene. The only thing that is interesting for - // us is the primary camera. - if (XmlParser::hasAttribute(currentNode, "camera_node")) { - std::string s; - XmlParser::getStdStrAttribute(currentNode, "camera_node", s); - if (s[0] != '#') { - ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera"); - } else { - pNode->mPrimaryCamera = s.c_str() + 1; - } - } - } else if (currentName == "instance_node") { - // find the node in the library - if (XmlParser::hasAttribute(currentNode, "url")) { - std::string s; - XmlParser::getStdStrAttribute(currentNode, "url", s); - if (s[0] != '#') { - ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node"); - } else { - pNode->mNodeInstances.push_back(NodeInstance()); - pNode->mNodeInstances.back().mNode = s.c_str() + 1; - } - } - } else if (currentName == "instance_geometry" || currentName == "instance_controller") { - // Reference to a mesh or controller, with possible material associations - ReadNodeGeometry(currentNode, pNode); - } else if (currentName == "instance_light") { - // Reference to a light, name given in 'url' attribute - if (XmlParser::hasAttribute(currentNode, "url")) { - std::string url; - XmlParser::getStdStrAttribute(currentNode, "url", url); - if (url[0] != '#') { - throw DeadlyImportError("Unknown reference format in element"); - } - - pNode->mLights.push_back(LightInstance()); - pNode->mLights.back().mLight = url.c_str() + 1; - } - } else if (currentName == "instance_camera") { - // Reference to a camera, name given in 'url' attribute - if (XmlParser::hasAttribute(currentNode, "url")) { - std::string url; - XmlParser::getStdStrAttribute(currentNode, "url", url); - if (url[0] != '#') { - throw DeadlyImportError("Unknown reference format in element"); - } - pNode->mCameras.push_back(CameraInstance()); - pNode->mCameras.back().mCamera = url.c_str() + 1; - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a node transformation entry of the given type and adds it to the given node's transformation list. -void ColladaParser::ReadNodeTransformation(XmlNode &node, Node *pNode, TransformType pType) { - if (node.empty()) { - return; - } - - std::string tagName = node.name(); - - Transform tf; - tf.mType = pType; - - // read SID - if (XmlParser::hasAttribute(node, "sid")) { - XmlParser::getStdStrAttribute(node, "sid", tf.mID); - } - - // how many parameters to read per transformation type - static const unsigned int sNumParameters[] = { 9, 4, 3, 3, 7, 16 }; - std::string value; - XmlParser::getValueAsString(node, value); - const char *content = value.c_str(); - - // read as many parameters and store in the transformation - for (unsigned int a = 0; a < sNumParameters[pType]; a++) { - // skip whitespace before the number - SkipSpacesAndLineEnd(&content); - // read a number - content = fast_atoreal_move(content, tf.f[a]); - } - - // place the transformation at the queue of the node - pNode->mTransforms.push_back(tf); -} - -// ------------------------------------------------------------------------------------------------ -// Processes bind_vertex_input and bind elements -void ColladaParser::ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl) { - std::string name = node.name(); - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "bind_vertex_input") { - Collada::InputSemanticMapEntry vn; - - // effect semantic - if (XmlParser::hasAttribute(currentNode, "semantic")) { - std::string s; - XmlParser::getStdStrAttribute(currentNode, "semantic", s); - XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType); - } - std::string s; - XmlParser::getStdStrAttribute(currentNode, "semantic", s); - - // input semantic - XmlParser::getUIntAttribute(currentNode, "input_semantic", (unsigned int &)vn.mType); - - // index of input set - if (XmlParser::hasAttribute(currentNode, "input_set")) { - XmlParser::getUIntAttribute(currentNode, "input_set", vn.mSet); - } - - tbl.mMap[s] = vn; - } else if (currentName == "bind") { - ASSIMP_LOG_WARN("Collada: Found unsupported element"); - } - } -} - -void ColladaParser::ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive) { - // Attempt to load any undefined Collada::Image in ImageLibrary - for (auto &it : mImageLibrary) { - Collada::Image &image = it.second; - - if (image.mImageData.empty()) { - std::unique_ptr image_file(zip_archive.Open(image.mFileName.c_str())); - if (image_file) { - image.mImageData.resize(image_file->FileSize()); - image_file->Read(image.mImageData.data(), image_file->FileSize(), 1); - image.mEmbeddedFormat = BaseImporter::GetExtension(image.mFileName); - if (image.mEmbeddedFormat == "jpeg") { - image.mEmbeddedFormat = "jpg"; - } - } - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Reads a mesh reference in a node and adds it to the node's mesh list -void ColladaParser::ReadNodeGeometry(XmlNode &node, Node *pNode) { - // referred mesh is given as an attribute of the element - std::string url; - XmlParser::getStdStrAttribute(node, "url", url); - if (url[0] != '#') { - throw DeadlyImportError("Unknown reference format"); - } - - Collada::MeshInstance instance; - instance.mMeshOrController = url.c_str() + 1; // skipping the leading # - - for (XmlNode currentNode = node.first_child(); currentNode; currentNode = currentNode.next_sibling()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "bind_material") { - XmlNode techNode = currentNode.child("technique_common"); - if (techNode) { - for (XmlNode instanceMatNode = techNode.child("instance_material"); instanceMatNode; instanceMatNode = instanceMatNode.next_sibling()) - { - const std::string &instance_name = instanceMatNode.name(); - if (instance_name == "instance_material") - { - // read ID of the geometry subgroup and the target material - std::string group; - XmlParser::getStdStrAttribute(instanceMatNode, "symbol", group); - XmlParser::getStdStrAttribute(instanceMatNode, "target", url); - const char *urlMat = url.c_str(); - Collada::SemanticMappingTable s; - if (urlMat[0] == '#') - urlMat++; - - s.mMatName = urlMat; - // store the association - instance.mMaterials[group] = s; - ReadMaterialVertexInputBinding(instanceMatNode, s); - } - } - } - } - } - - // store it - pNode->mMeshes.push_back(instance); -} - -// ------------------------------------------------------------------------------------------------ -// Reads the collada scene -void ColladaParser::ReadScene(XmlNode &node) { - if (node.empty()) { - return; - } - - for (XmlNode ¤tNode : node.children()) { - const std::string ¤tName = currentNode.name(); - if (currentName == "instance_visual_scene") { - // should be the first and only occurrence - if (mRootNode) { - throw DeadlyImportError("Invalid scene containing multiple root nodes in element"); - } - - // read the url of the scene to instance. Should be of format "#some_name" - std::string url; - XmlParser::getStdStrAttribute(currentNode, "url", url); - if (url[0] != '#') { - throw DeadlyImportError("Unknown reference format in element"); - } - - // find the referred scene, skip the leading # - NodeLibrary::const_iterator sit = mNodeLibrary.find(url.c_str() + 1); - if (sit == mNodeLibrary.end()) { - throw DeadlyImportError("Unable to resolve visual_scene reference \"", std::string(url), "\" in element."); - } - mRootNode = sit->second; - } - } -} - -// ------------------------------------------------------------------------------------------------ -// Calculates the resulting transformation from all the given transform steps -aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector &pTransforms) const { - aiMatrix4x4 res; - - for (std::vector::const_iterator it = pTransforms.begin(); it != pTransforms.end(); ++it) { - const Transform &tf = *it; - switch (tf.mType) { - case TF_LOOKAT: { - aiVector3D pos(tf.f[0], tf.f[1], tf.f[2]); - aiVector3D dstPos(tf.f[3], tf.f[4], tf.f[5]); - aiVector3D up = aiVector3D(tf.f[6], tf.f[7], tf.f[8]).Normalize(); - aiVector3D dir = aiVector3D(dstPos - pos).Normalize(); - aiVector3D right = (dir ^ up).Normalize(); - - res *= aiMatrix4x4( - right.x, up.x, -dir.x, pos.x, - right.y, up.y, -dir.y, pos.y, - right.z, up.z, -dir.z, pos.z, - 0, 0, 0, 1); - break; - } - case TF_ROTATE: { - aiMatrix4x4 rot; - ai_real angle = tf.f[3] * ai_real(AI_MATH_PI) / ai_real(180.0); - aiVector3D axis(tf.f[0], tf.f[1], tf.f[2]); - aiMatrix4x4::Rotation(angle, axis, rot); - res *= rot; - break; - } - case TF_TRANSLATE: { - aiMatrix4x4 trans; - aiMatrix4x4::Translation(aiVector3D(tf.f[0], tf.f[1], tf.f[2]), trans); - res *= trans; - break; - } - case TF_SCALE: { - aiMatrix4x4 scale(tf.f[0], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[1], 0.0f, 0.0f, 0.0f, 0.0f, tf.f[2], 0.0f, - 0.0f, 0.0f, 0.0f, 1.0f); - res *= scale; - break; - } - case TF_SKEW: - // TODO: (thom) - ai_assert(false); - break; - case TF_MATRIX: { - aiMatrix4x4 mat(tf.f[0], tf.f[1], tf.f[2], tf.f[3], tf.f[4], tf.f[5], tf.f[6], tf.f[7], - tf.f[8], tf.f[9], tf.f[10], tf.f[11], tf.f[12], tf.f[13], tf.f[14], tf.f[15]); - res *= mat; - break; - } - default: - ai_assert(false); - break; - } - } - - return res; -} - -// ------------------------------------------------------------------------------------------------ -// Determines the input data type for the given semantic string -Collada::InputType ColladaParser::GetTypeForSemantic(const std::string &semantic) { - if (semantic.empty()) { - ASSIMP_LOG_WARN("Vertex input type is empty."); - return IT_Invalid; - } - - if (semantic == "POSITION") - return IT_Position; - else if (semantic == "TEXCOORD") - return IT_Texcoord; - else if (semantic == "NORMAL") - return IT_Normal; - else if (semantic == "COLOR") - return IT_Color; - else if (semantic == "VERTEX") - return IT_Vertex; - else if (semantic == "BINORMAL" || semantic == "TEXBINORMAL") - return IT_Bitangent; - else if (semantic == "TANGENT" || semantic == "TEXTANGENT") - return IT_Tangent; - - ASSIMP_LOG_WARN("Unknown vertex input type \"", semantic, "\". Ignoring."); - return IT_Invalid; -} - -#endif // !! ASSIMP_BUILD_NO_DAE_IMPORTER diff --git a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h b/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h deleted file mode 100644 index 1598293..0000000 --- a/src/mesh/assimp-master/code/AssetLib/Collada/ColladaParser.h +++ /dev/null @@ -1,348 +0,0 @@ -/* - 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 ColladaParser.h - * @brief Defines the parser helper class for the collada loader - */ - -#pragma once -#ifndef AI_COLLADAPARSER_H_INC -#define AI_COLLADAPARSER_H_INC - -#include "ColladaHelper.h" -#include -#include -#include - -#include - -namespace Assimp { - -class ZipArchiveIOSystem; - -// ------------------------------------------------------------------------------------------ -/** Parser helper class for the Collada loader. - * - * Does all the XML reading and builds internal data structures from it, - * but leaves the resolving of all the references to the loader. - */ -class ColladaParser { - friend class ColladaLoader; - - /** Converts a path read from a collada file to the usual representation */ - static void UriDecodePath(aiString &ss); - -protected: - /** Map for generic metadata as aiString */ - typedef std::map StringMetaData; - - /** Constructor from XML file */ - ColladaParser(IOSystem *pIOHandler, const std::string &pFile); - - /** Destructor */ - ~ColladaParser(); - - /** Attempts to read the ZAE manifest and returns the DAE to open */ - static std::string ReadZaeManifest(ZipArchiveIOSystem &zip_archive); - - /** Reads the contents of the file */ - void ReadContents(XmlNode &node); - - /** Reads the structure of the file */ - void ReadStructure(XmlNode &node); - - /** Reads asset information such as coordinate system information and legal blah */ - void ReadAssetInfo(XmlNode &node); - - /** Reads contributor information such as author and legal blah */ - void ReadContributorInfo(XmlNode &node); - - /** Reads generic metadata into provided map and renames keys for Assimp */ - void ReadMetaDataItem(XmlNode &node, StringMetaData &metadata); - - /** Reads the animation library */ - void ReadAnimationLibrary(XmlNode &node); - - /** Reads the animation clip library */ - void ReadAnimationClipLibrary(XmlNode &node); - - /** Unwrap controllers dependency hierarchy */ - void PostProcessControllers(); - - /** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */ - void PostProcessRootAnimations(); - - /** Reads an animation into the given parent structure */ - void ReadAnimation(XmlNode &node, Collada::Animation *pParent); - - /** Reads an animation sampler into the given anim channel */ - void ReadAnimationSampler(XmlNode &node, Collada::AnimationChannel &pChannel); - - /** Reads the skeleton controller library */ - void ReadControllerLibrary(XmlNode &node); - - /** Reads a controller into the given mesh structure */ - void ReadController(XmlNode &node, Collada::Controller &pController); - - /** Reads the joint definitions for the given controller */ - void ReadControllerJoints(XmlNode &node, Collada::Controller &pController); - - /** Reads the joint weights for the given controller */ - void ReadControllerWeights(XmlNode &node, Collada::Controller &pController); - - /** Reads the image library contents */ - void ReadImageLibrary(XmlNode &node); - - /** Reads an image entry into the given image */ - void ReadImage(XmlNode &node, Collada::Image &pImage); - - /** Reads the material library */ - void ReadMaterialLibrary(XmlNode &node); - - /** Reads a material entry into the given material */ - void ReadMaterial(XmlNode &node, Collada::Material &pMaterial); - - /** Reads the camera library */ - void ReadCameraLibrary(XmlNode &node); - - /** Reads a camera entry into the given camera */ - void ReadCamera(XmlNode &node, Collada::Camera &pCamera); - - /** Reads the light library */ - void ReadLightLibrary(XmlNode &node); - - /** Reads a light entry into the given light */ - void ReadLight(XmlNode &node, Collada::Light &pLight); - - /** Reads the effect library */ - void ReadEffectLibrary(XmlNode &node); - - /** Reads an effect entry into the given effect*/ - void ReadEffect(XmlNode &node, Collada::Effect &pEffect); - - /** Reads an COMMON effect profile */ - void ReadEffectProfileCommon(XmlNode &node, Collada::Effect &pEffect); - - /** Read sampler properties */ - void ReadSamplerProperties(XmlNode &node, Collada::Sampler &pSampler); - - /** Reads an effect entry containing a color or a texture defining that color */ - void ReadEffectColor(XmlNode &node, aiColor4D &pColor, Collada::Sampler &pSampler); - - /** Reads an effect entry containing a float */ - void ReadEffectFloat(XmlNode &node, ai_real &pFloat); - - /** Reads an effect parameter specification of any kind */ - void ReadEffectParam(XmlNode &node, Collada::EffectParam &pParam); - - /** Reads the geometry library contents */ - void ReadGeometryLibrary(XmlNode &node); - - /** Reads a geometry from the geometry library. */ - void ReadGeometry(XmlNode &node, Collada::Mesh &pMesh); - - /** Reads a mesh from the geometry library */ - void ReadMesh(XmlNode &node, Collada::Mesh &pMesh); - - /** Reads a source element - a combination of raw data and an accessor defining - * things that should not be redefinable. Yes, that's another rant. - */ - void ReadSource(XmlNode &node); - - /** Reads a data array holding a number of elements, and stores it in the global library. - * Currently supported are array of floats and arrays of strings. - */ - void ReadDataArray(XmlNode &node); - - /** Reads an accessor and stores it in the global library under the given ID - - * accessors use the ID of the parent element - */ - void ReadAccessor(XmlNode &node, const std::string &pID); - - /** Reads input declarations of per-vertex mesh data into the given mesh */ - void ReadVertexData(XmlNode &node, Collada::Mesh &pMesh); - - /** Reads input declarations of per-index mesh data into the given mesh */ - void ReadIndexData(XmlNode &node, Collada::Mesh &pMesh); - - /** Reads a single input channel element and stores it in the given array, if valid */ - void ReadInputChannel(XmlNode &node, std::vector &poChannels); - - /** Reads a

primitive index list and assembles the mesh data into the given mesh */ - size_t ReadPrimitives(XmlNode &node, Collada::Mesh &pMesh, std::vector &pPerIndexChannels, - size_t pNumPrimitives, const std::vector &pVCount, Collada::PrimitiveType pPrimType); - - /** Copies the data for a single primitive into the mesh, based on the InputChannels */ - void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, - Collada::Mesh &pMesh, std::vector &pPerIndexChannels, - size_t currentPrimitive, const std::vector &indices); - - /** Reads one triangle of a tristrip into the mesh */ - void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh &pMesh, - std::vector &pPerIndexChannels, size_t currentPrimitive, const std::vector &indices); - - /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */ - void ExtractDataObjectFromChannel(const Collada::InputChannel &pInput, size_t pLocalIndex, Collada::Mesh &pMesh); - - /** Reads the library of node hierarchies and scene parts */ - void ReadSceneLibrary(XmlNode &node); - - /** Reads a scene node's contents including children and stores it in the given node */ - void ReadSceneNode(XmlNode &node, Collada::Node *pNode); - - /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */ - void ReadNodeTransformation(XmlNode &node, Collada::Node *pNode, Collada::TransformType pType); - - /** Reads a mesh reference in a node and adds it to the node's mesh list */ - void ReadNodeGeometry(XmlNode &node, Collada::Node *pNode); - - /** Reads the collada scene */ - void ReadScene(XmlNode &node); - - // Processes bind_vertex_input and bind elements - void ReadMaterialVertexInputBinding(XmlNode &node, Collada::SemanticMappingTable &tbl); - - /** Reads embedded textures from a ZAE archive*/ - void ReadEmbeddedTextures(ZipArchiveIOSystem &zip_archive); - -protected: - /** Calculates the resulting transformation from all the given transform steps */ - aiMatrix4x4 CalculateResultTransform(const std::vector &pTransforms) const; - - /** Determines the input data type for the given semantic string */ - Collada::InputType GetTypeForSemantic(const std::string &pSemantic); - - /** Finds the item in the given library by its reference, throws if not found */ - template - const Type &ResolveLibraryReference(const std::map &pLibrary, const std::string &pURL) const; - -protected: - // Filename, for a verbose error message - std::string mFileName; - - // XML reader, member for everyday use - XmlParser mXmlParser; - - /** All data arrays found in the file by ID. Might be referred to by actually - everyone. Collada, you are a steaming pile of indirection. */ - using DataLibrary = std::map ; - DataLibrary mDataLibrary; - - /** Same for accessors which define how the data in a data array is accessed. */ - using AccessorLibrary = std::map ; - AccessorLibrary mAccessorLibrary; - - /** Mesh library: mesh by ID */ - using MeshLibrary = std::map; - MeshLibrary mMeshLibrary; - - /** node library: root node of the hierarchy part by ID */ - using NodeLibrary = std::map; - NodeLibrary mNodeLibrary; - - /** Image library: stores texture properties by ID */ - using ImageLibrary = std::map ; - ImageLibrary mImageLibrary; - - /** Effect library: surface attributes by ID */ - using EffectLibrary = std::map ; - EffectLibrary mEffectLibrary; - - /** Material library: surface material by ID */ - using MaterialLibrary = std::map ; - MaterialLibrary mMaterialLibrary; - - /** Light library: surface light by ID */ - using LightLibrary = std::map ; - LightLibrary mLightLibrary; - - /** Camera library: surface material by ID */ - using CameraLibrary = std::map ; - CameraLibrary mCameraLibrary; - - /** Controller library: joint controllers by ID */ - using ControllerLibrary = std::map ; - ControllerLibrary mControllerLibrary; - - /** Animation library: animation references by ID */ - using AnimationLibrary = std::map ; - AnimationLibrary mAnimationLibrary; - - /** Animation clip library: clip animation references by ID */ - using AnimationClipLibrary = std::vector>> ; - AnimationClipLibrary mAnimationClipLibrary; - - /** Pointer to the root node. Don't delete, it just points to one of - the nodes in the node library. */ - Collada::Node *mRootNode; - - /** Root animation container */ - Collada::Animation mAnims; - - /** Size unit: how large compared to a meter */ - ai_real mUnitSize; - - /** Which is the up vector */ - enum { UP_X, - UP_Y, - UP_Z } mUpDirection; - - /** Asset metadata (global for scene) */ - StringMetaData mAssetMetaData; - - /** Collada file format version */ - Collada::FormatVersion mFormat; -}; - -// ------------------------------------------------------------------------------------------------ -// Finds the item in the given library by its reference, throws if not found -template -const Type &ColladaParser::ResolveLibraryReference(const std::map &pLibrary, const std::string &pURL) const { - typename std::map::const_iterator it = pLibrary.find(pURL); - if (it == pLibrary.end()) { - throw DeadlyImportError("Unable to resolve library reference \"", pURL, "\"."); - } - return it->second; -} - -} // end of namespace Assimp - -#endif // AI_COLLADAPARSER_H_INC -- cgit v1.2.1