summaryrefslogtreecommitdiff
path: root/libs/assimp/code/AssetLib/Collada
diff options
context:
space:
mode:
authorsanine <sanine.not@pm.me>2022-04-16 11:55:09 -0500
committersanine <sanine.not@pm.me>2022-04-16 11:55:09 -0500
commitdb81b925d776103326128bf629cbdda576a223e7 (patch)
tree58bea8155c686733310009f6bed7363f91fbeb9d /libs/assimp/code/AssetLib/Collada
parent55860037b14fb3893ba21cf2654c83d349cc1082 (diff)
move 3rd-party librarys into libs/ and add built-in honeysuckle
Diffstat (limited to 'libs/assimp/code/AssetLib/Collada')
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaExporter.cpp1748
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaExporter.h257
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaHelper.cpp99
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaHelper.h679
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaLoader.cpp1828
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaLoader.h249
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaParser.cpp2402
-rw-r--r--libs/assimp/code/AssetLib/Collada/ColladaParser.h348
8 files changed, 7610 insertions, 0 deletions
diff --git a/libs/assimp/code/AssetLib/Collada/ColladaExporter.cpp b/libs/assimp/code/AssetLib/Collada/ColladaExporter.cpp
new file mode 100644
index 0000000..5c91daa
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaExporter.cpp
@@ -0,0 +1,1748 @@
+/*
+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 <assimp/Bitmap.h>
+#include <assimp/ColladaMetaData.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/Exceptional.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XMLTools.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/scene.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <ctime>
+#include <memory>
+
+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<IOStream> 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<size_t>(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<std::string> &idSet, const std::string &idStr) {
+ return (idSet.find(idStr) == idSet.end());
+}
+
+inline std::string MakeUniqueId(const std::unordered_set<std::string> &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 << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
+ // COLLADA element start
+ mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << 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 << "<scene>" << endstr;
+ PushTag();
+ mOutput << startstr << "<instance_visual_scene url=\"#" + mSceneId + "\" />" << endstr;
+ PopTag();
+ mOutput << startstr << "</scene>" << endstr;
+ PopTag();
+ mOutput << "</COLLADA>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the asset header
+void ColladaExporter::WriteHeader() {
+ static const ai_real epsilon = Math::getEpsilon<ai_real>();
+ 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 << "<asset>" << endstr;
+ PushTag();
+ mOutput << startstr << "<contributor>" << 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 << "<author>"
+ << "Assimp"
+ << "</author>" << endstr;
+ } else {
+ mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
+ }
+
+ if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
+ mOutput << startstr << "<authoring_tool>"
+ << "Assimp Exporter"
+ << "</authoring_tool>" << endstr;
+ } else {
+ mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
+ }
+
+ if (meta) {
+ if (meta->Get("Comments", value)) {
+ mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
+ }
+ if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
+ mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
+ }
+ if (meta->Get("SourceData", value)) {
+ mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
+ }
+ }
+
+ PopTag();
+ mOutput << startstr << "</contributor>" << endstr;
+
+ if (nullptr == meta || !meta->Get("Created", value)) {
+ mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
+ } else {
+ mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
+ }
+
+ // Modified date is always the date saved
+ mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
+
+ if (meta) {
+ if (meta->Get("Keywords", value)) {
+ mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
+ }
+ if (meta->Get("Revision", value)) {
+ mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
+ }
+ if (meta->Get("Subject", value)) {
+ mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
+ }
+ if (meta->Get("Title", value)) {
+ mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
+ }
+ }
+
+ mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
+ mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
+ PopTag();
+ mOutput << startstr << "</asset>" << 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<IOStream> 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 << "<library_cameras>" << endstr;
+ PushTag();
+
+ for (size_t a = 0; a < mScene->mNumCameras; ++a)
+ WriteCamera(a);
+
+ PopTag();
+ mOutput << startstr << "</library_cameras>" << 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 << "<camera id=\"" << cameraId << "\" name=\"" << cameraName << "\" >" << endstr;
+ PushTag();
+ mOutput << startstr << "<optics>" << endstr;
+ PushTag();
+ mOutput << startstr << "<technique_common>" << endstr;
+ PushTag();
+ //assimp doesn't support the import of orthographic cameras! se we write
+ //always perspective
+ mOutput << startstr << "<perspective>" << endstr;
+ PushTag();
+ mOutput << startstr << "<xfov sid=\"xfov\">" << AI_RAD_TO_DEG(cam->mHorizontalFOV)
+ << "</xfov>" << endstr;
+ mOutput << startstr << "<aspect_ratio>"
+ << cam->mAspect
+ << "</aspect_ratio>" << endstr;
+ mOutput << startstr << "<znear sid=\"znear\">"
+ << cam->mClipPlaneNear
+ << "</znear>" << endstr;
+ mOutput << startstr << "<zfar sid=\"zfar\">"
+ << cam->mClipPlaneFar
+ << "</zfar>" << endstr;
+ PopTag();
+ mOutput << startstr << "</perspective>" << endstr;
+ PopTag();
+ mOutput << startstr << "</technique_common>" << endstr;
+ PopTag();
+ mOutput << startstr << "</optics>" << endstr;
+ PopTag();
+ mOutput << startstr << "</camera>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteLightsLibrary() {
+ if (mScene->HasLights()) {
+
+ mOutput << startstr << "<library_lights>" << endstr;
+ PushTag();
+
+ for (size_t a = 0; a < mScene->mNumLights; ++a)
+ WriteLight(a);
+
+ PopTag();
+ mOutput << startstr << "</library_lights>" << 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 << "<light id=\"" << lightId << "\" name=\""
+ << lightName << "\" >" << endstr;
+ PushTag();
+ mOutput << startstr << "<technique_common>" << 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 << "</technique_common>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</light>" << endstr;
+}
+
+void ColladaExporter::WritePointLight(const aiLight *const light) {
+ const aiColor3D &color = light->mColorDiffuse;
+ mOutput << startstr << "<point>" << endstr;
+ PushTag();
+ mOutput << startstr << "<color sid=\"color\">"
+ << color.r << " " << color.g << " " << color.b
+ << "</color>" << endstr;
+ mOutput << startstr << "<constant_attenuation>"
+ << light->mAttenuationConstant
+ << "</constant_attenuation>" << endstr;
+ mOutput << startstr << "<linear_attenuation>"
+ << light->mAttenuationLinear
+ << "</linear_attenuation>" << endstr;
+ mOutput << startstr << "<quadratic_attenuation>"
+ << light->mAttenuationQuadratic
+ << "</quadratic_attenuation>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</point>" << endstr;
+}
+
+void ColladaExporter::WriteDirectionalLight(const aiLight *const light) {
+ const aiColor3D &color = light->mColorDiffuse;
+ mOutput << startstr << "<directional>" << endstr;
+ PushTag();
+ mOutput << startstr << "<color sid=\"color\">"
+ << color.r << " " << color.g << " " << color.b
+ << "</color>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</directional>" << endstr;
+}
+
+void ColladaExporter::WriteSpotLight(const aiLight *const light) {
+
+ const aiColor3D &color = light->mColorDiffuse;
+ mOutput << startstr << "<spot>" << endstr;
+ PushTag();
+ mOutput << startstr << "<color sid=\"color\">"
+ << color.r << " " << color.g << " " << color.b
+ << "</color>" << endstr;
+ mOutput << startstr << "<constant_attenuation>"
+ << light->mAttenuationConstant
+ << "</constant_attenuation>" << endstr;
+ mOutput << startstr << "<linear_attenuation>"
+ << light->mAttenuationLinear
+ << "</linear_attenuation>" << endstr;
+ mOutput << startstr << "<quadratic_attenuation>"
+ << light->mAttenuationQuadratic
+ << "</quadratic_attenuation>" << 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 << "<falloff_angle sid=\"fall_off_angle\">"
+ << fallOffAngle
+ << "</falloff_angle>" << endstr;
+ double temp = light->mAngleOuterCone - light->mAngleInnerCone;
+
+ temp = std::cos(temp);
+ temp = std::log(temp) / std::log(0.1);
+ temp = 1 / temp;
+ mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
+ << temp
+ << "</falloff_exponent>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</spot>" << endstr;
+}
+
+void ColladaExporter::WriteAmbienttLight(const aiLight *const light) {
+
+ const aiColor3D &color = light->mColorAmbient;
+ mOutput << startstr << "<ambient>" << endstr;
+ PushTag();
+ mOutput << startstr << "<color sid=\"color\">"
+ << color.r << " " << color.g << " " << color.b
+ << "</color>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</ambient>" << 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<DeadlyExportError>(index_str.c_str());
+ } catch (std::exception &error) {
+ throw DeadlyExportError(error.what());
+ }
+
+ std::map<unsigned int, std::string>::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<unsigned int>(pType), static_cast<unsigned int>(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 << "<image id=\"" << imageId << "\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<init_from>";
+
+ // 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 << "</init_from>" << endstr;
+ PopTag();
+ mOutput << startstr << "</image>" << 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 << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << " " << pSurface.color.g << " " << pSurface.color.b << " " << pSurface.color.a << "</color>" << endstr;
+ } else {
+ mOutput << startstr << "<texture texture=\"" << imageId << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+ }
+ PopTag();
+ mOutput << startstr << "</" << pTypeName << ">" << 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 << "<newparam sid=\"" << materialId << "-" << pTypeName << "-surface\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<surface type=\"2D\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<init_from>" << materialId << "-" << pTypeName << "-image</init_from>" << endstr;
+ PopTag();
+ mOutput << startstr << "</surface>" << endstr;
+ PopTag();
+ mOutput << startstr << "</newparam>" << endstr;
+
+ mOutput << startstr << "<newparam sid=\"" << materialId << "-" << pTypeName << "-sampler\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<sampler2D>" << endstr;
+ PushTag();
+ mOutput << startstr << "<source>" << materialId << "-" << pTypeName << "-surface</source>" << endstr;
+ PopTag();
+ mOutput << startstr << "</sampler2D>" << endstr;
+ PopTag();
+ mOutput << startstr << "</newparam>" << 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 << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
+ PopTag();
+ mOutput << startstr << "</" << pTypeName << ">" << endstr;
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the material setup
+void ColladaExporter::WriteMaterials() {
+ std::vector<Material> 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 << "<library_images>" << 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 << "</library_images>" << endstr;
+ }
+
+ // output effects - those are the actual carriers of information
+ if (!materials.empty()) {
+ mOutput << startstr << "<library_effects>" << endstr;
+ PushTag();
+ for (const Material &mat : materials) {
+ // this is so ridiculous it must be right
+ mOutput << startstr << "<effect id=\"" << mat.id << "-fx\" name=\"" << mat.name << "\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<profile_COMMON>" << 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 << "<technique sid=\"standard\">" << 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 << "</" << mat.shading_model << ">" << endstr;
+ PopTag();
+ mOutput << startstr << "</technique>" << endstr;
+ PopTag();
+ mOutput << startstr << "</profile_COMMON>" << endstr;
+ PopTag();
+ mOutput << startstr << "</effect>" << endstr;
+ }
+ PopTag();
+ mOutput << startstr << "</library_effects>" << endstr;
+
+ // write materials - they're just effect references
+ mOutput << startstr << "<library_materials>" << endstr;
+ PushTag();
+ for (std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+ const Material &mat = *it;
+ mOutput << startstr << "<material id=\"" << mat.id << "\" name=\"" << mat.name << "\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<instance_effect url=\"#" << mat.id << "-fx\"/>" << endstr;
+ PopTag();
+ mOutput << startstr << "</material>" << endstr;
+ }
+ PopTag();
+ mOutput << startstr << "</library_materials>" << endstr;
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the controller library
+void ColladaExporter::WriteControllerLibrary() {
+ mOutput << startstr << "<library_controllers>" << endstr;
+ PushTag();
+
+ for (size_t a = 0; a < mScene->mNumMeshes; ++a) {
+ WriteController(a);
+ }
+
+ PopTag();
+ mOutput << startstr << "</library_controllers>" << 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 << "<controller id=\"" << idstr << "-skin\" ";
+ mOutput << "name=\"skinCluster" << pIndex << "\">" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<skin source=\"#" << idstr << "\">" << endstr;
+ PushTag();
+
+ // bind pose matrix
+ mOutput << startstr << "<bind_shape_matrix>" << 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 << "</bind_shape_matrix>" << endstr;
+
+ mOutput << startstr << "<source id=\"" << idstr << "-skin-joints\" name=\"" << namestr << "-skin-joints\">" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<Name_array id=\"" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
+
+ for (size_t i = 0; i < mesh->mNumBones; ++i)
+ mOutput << GetBoneUniqueId(mesh->mBones[i]) << ' ';
+
+ mOutput << "</Name_array>" << endstr;
+
+ mOutput << startstr << "<technique_common>" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<accessor source=\"#" << idstr << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</accessor>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</technique_common>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</source>" << endstr;
+
+ std::vector<ai_real> 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<ai_real> 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 << "<joints>" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstr << "-skin-joints\"></input>" << endstr;
+ mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstr << "-skin-bind_poses\"></input>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</joints>" << endstr;
+
+ mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstr << "-skin-joints\" offset=\"0\"></input>" << endstr;
+ mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstr << "-skin-weights\" offset=\"1\"></input>" << endstr;
+
+ mOutput << startstr << "<vcount>";
+
+ std::vector<ai_uint> 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 << "</vcount>" << endstr;
+
+ mOutput << startstr << "<v>";
+
+ ai_uint joint_weight_indices_length = 0;
+ std::vector<ai_uint> 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<ai_int> 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 << "</v>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</vertex_weights>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</skin>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</controller>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the geometry library
+void ColladaExporter::WriteGeometryLibrary() {
+ mOutput << startstr << "<library_geometries>" << endstr;
+ PushTag();
+
+ for (size_t a = 0; a < mScene->mNumMeshes; ++a)
+ WriteGeometry(a);
+
+ PopTag();
+ mOutput << startstr << "</library_geometries>" << 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 << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<mesh>" << 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<unsigned int>(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<unsigned int>(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 << "<vertices id=\"" << geometryId << "-vertices"
+ << "\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
+ PopTag();
+ mOutput << startstr << "</vertices>" << 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 << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+ if (mesh->HasNormals())
+ mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+ for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+ if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+ mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+ << "set=\"" << a << "\""
+ << " />" << endstr;
+ }
+ for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+ if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+ mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+ << "set=\"" << a << "\""
+ << " />" << endstr;
+ }
+
+ mOutput << startstr << "<p>";
+ 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 << "</p>" << endstr;
+ PopTag();
+ mOutput << startstr << "</lines>" << endstr;
+ }
+
+ // triangle - don't use it, because compatibility problems
+
+ // polygons
+ if (countPoly) {
+ mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
+ PushTag();
+ mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+ if (mesh->HasNormals())
+ mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+ for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+ if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+ mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+ << "set=\"" << a << "\""
+ << " />" << endstr;
+ }
+ for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+ if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+ mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+ << "set=\"" << a << "\""
+ << " />" << endstr;
+ }
+
+ mOutput << startstr << "<vcount>";
+ for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+ if (mesh->mFaces[a].mNumIndices < 3) continue;
+ mOutput << mesh->mFaces[a].mNumIndices << " ";
+ }
+ mOutput << "</vcount>" << endstr;
+
+ mOutput << startstr << "<p>";
+ 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 << "</p>" << endstr;
+ PopTag();
+ mOutput << startstr << "</polylist>" << endstr;
+ }
+
+ // closing tags
+ PopTag();
+ mOutput << startstr << "</mesh>" << endstr;
+ PopTag();
+ mOutput << startstr << "</geometry>" << 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 << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
+ PushTag();
+
+ // source array
+ mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
+ 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 << "</float_array>" << endstr;
+ PopTag();
+
+ // the usual Collada fun. Let's bloat it even more!
+ mOutput << startstr << "<technique_common>" << endstr;
+ PushTag();
+ mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
+ PushTag();
+
+ switch (pType) {
+ case FloatType_Vector:
+ mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
+ break;
+
+ case FloatType_TexCoord2:
+ mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+ break;
+
+ case FloatType_TexCoord3:
+ mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
+ break;
+
+ case FloatType_Color:
+ mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
+ mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
+ break;
+
+ case FloatType_Mat4x4:
+ mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
+ break;
+
+ case FloatType_Weight:
+ mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
+ break;
+
+ // customized, add animation related
+ case FloatType_Time:
+ mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
+ break;
+ }
+
+ PopTag();
+ mOutput << startstr << "</accessor>" << endstr;
+ PopTag();
+ mOutput << startstr << "</technique_common>" << endstr;
+ PopTag();
+ mOutput << startstr << "</source>" << 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 << "<library_visual_scenes>" << endstr;
+ PushTag();
+ mOutput << startstr << "<visual_scene id=\"" + mSceneId + "\" name=\"" + sceneName + "\">" << 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 << "</visual_scene>" << endstr;
+ PopTag();
+ mOutput << startstr << "</library_visual_scenes>" << 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 << "<animation id=\"" + idstrEscaped + "\" name=\"" + animationNameEscaped + "\">" << 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<ai_real> frames;
+ for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+ frames.push_back(static_cast<ai_real>(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<ai_real> 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<std::string> 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 << "<source id=\"" << XMLIDEncode(cur_node_idstr2) << "\">" << endstr;
+ PushTag();
+
+ // source array
+ mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
+ for (size_t aa = 0; aa < names.size(); ++aa) {
+ mOutput << names[aa] << " ";
+ }
+ mOutput << "</Name_array>" << endstr;
+
+ mOutput << startstr << "<technique_common>" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</accessor>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</technique_common>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</source>" << 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 << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+ PushTag();
+
+ mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-input")) << "\"/>" << endstr;
+ mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-output")) << "\"/>" << endstr;
+ mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-interpolation")) << "\"/>" << endstr;
+
+ PopTag();
+ mOutput << startstr << "</sampler>" << endstr;
+ }
+ }
+
+ for (size_t a = 0; a < anim->mNumChannels; ++a) {
+ const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+ {
+ // channels
+ mOutput << startstr << "<channel source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-sampler")) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+ }
+ }
+
+ PopTag();
+ mOutput << startstr << "</animation>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationsLibrary() {
+ if (mScene->mNumAnimations > 0) {
+ mOutput << startstr << "<library_animations>" << endstr;
+ PushTag();
+
+ // start recursive write at the root node
+ for (size_t a = 0; a < mScene->mNumAnimations; ++a)
+ WriteAnimationLibrary(a);
+
+ PopTag();
+ mOutput << startstr << "</library_animations>" << 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<const aiNode *> 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 << "<node ";
+ if (is_skeleton_root) {
+ mFoundSkeletonRootNodeID = node_id; // For now, only support one skeleton in a scene.
+ }
+ mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id + "\" " : "");
+ mOutput << "name=\"" << node_name
+ << "\" type=\"" << node_type
+ << "\">" << 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 << "<matrix sid=\"transform\">";
+ mOutput << startstr << "<matrix sid=\"matrix\">";
+
+ 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 << "</matrix>" << 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 << "<instance_camera url=\"#" << GetObjectUniqueId(AiObjectType::Camera, i) << "\"/>" << 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 << "<instance_light url=\"#" << GetObjectUniqueId(AiObjectType::Light, i) << "\"/>" << 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 << "<instance_geometry url=\"#" << meshId << "\">" << endstr;
+ PushTag();
+ } else {
+ mOutput << startstr
+ << "<instance_controller url=\"#" << meshId << "-skin\">"
+ << 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 << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
+ }
+ mOutput << startstr << "<bind_material>" << endstr;
+ PushTag();
+ mOutput << startstr << "<technique_common>" << endstr;
+ PushTag();
+ mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << GetObjectUniqueId(AiObjectType::Material, mesh->mMaterialIndex) << "\">" << endstr;
+ PushTag();
+ for (size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa) {
+ if (mesh->HasTextureCoords(static_cast<unsigned int>(aa)))
+ // semantic as in <texture texcoord=...>
+ // input_semantic as in <input semantic=...>
+ // input_set as in <input set=...>
+ mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << aa << "\" input_semantic=\"TEXCOORD\" input_set=\"" << aa << "\"/>" << endstr;
+ }
+ PopTag();
+ mOutput << startstr << "</instance_material>" << endstr;
+ PopTag();
+ mOutput << startstr << "</technique_common>" << endstr;
+ PopTag();
+ mOutput << startstr << "</bind_material>" << endstr;
+
+ PopTag();
+ if (mesh->mNumBones == 0)
+ mOutput << startstr << "</instance_geometry>" << endstr;
+ else
+ mOutput << startstr << "</instance_controller>" << endstr;
+ }
+
+ // recurse into subnodes
+ for (size_t a = 0; a < pNode->mNumChildren; ++a)
+ WriteNode(pNode->mChildren[a]);
+
+ PopTag();
+ mOutput << startstr << "</node>" << 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/libs/assimp/code/AssetLib/Collada/ColladaExporter.h b/libs/assimp/code/AssetLib/Collada/ColladaExporter.h
new file mode 100644
index 0000000..56415fb
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaExporter.h
@@ -0,0 +1,257 @@
+/*
+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 <assimp/ai_assert.h>
+#include <assimp/material.h>
+
+#include <array>
+#include <map>
+#include <sstream>
+#include <unordered_set>
+#include <vector>
+
+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<size_t, std::string> IndexIdMap;
+ typedef std::pair<std::string, std::string> NameIdPair;
+ NameIdPair AddObjectIndexToMaps(AiObjectType type, size_t pIndex);
+
+ // Helpers
+ inline IndexIdMap &GetObjectIdMap(AiObjectType type) { return mObjectIdMap[static_cast<size_t>(type)]; }
+ inline IndexIdMap &GetObjectNameMap(AiObjectType type) { return mObjectNameMap[static_cast<size_t>(type)]; }
+
+private:
+ std::unordered_set<std::string> mUniqueIds; // Cache of used unique ids
+ std::map<const void *, std::string> mNodeIdMap; // Cache of encoded node and bone ids
+ std::array<IndexIdMap, static_cast<size_t>(AiObjectType::Count)> mObjectIdMap; // Cache of encoded unique IDs
+ std::array<IndexIdMap, static_cast<size_t>(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<unsigned int, std::string> 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/libs/assimp/code/AssetLib/Collada/ColladaHelper.cpp b/libs/assimp/code/AssetLib/Collada/ColladaHelper.cpp
new file mode 100644
index 0000000..0fb172f
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaHelper.cpp
@@ -0,0 +1,99 @@
+/*
+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 <assimp/ParsingUtils.h>
+#include <assimp/commonMetaData.h>
+
+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/libs/assimp/code/AssetLib/Collada/ColladaHelper.h b/libs/assimp/code/AssetLib/Collada/ColladaHelper.h
new file mode 100644
index 0000000..31d7b5a
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaHelper.h
@@ -0,0 +1,679 @@
+/*
+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 <assimp/light.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+
+#include <cstdint>
+#include <map>
+#include <set>
+#include <vector>
+
+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 <vertices> 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 <Collada, Assimp>
+using MetaKeyPair = std::pair<std::string, std::string>;
+using MetaKeyPairVector = std::vector<MetaKeyPair>;
+
+/// 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<std::string, InputSemanticMapEntry>;
+ 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<std::string, SemanticMappingTable> 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<Node *> mChildren;
+
+ /// Operations in order to calculate the resulting transformation to parent.
+ std::vector<Transform> mTransforms;
+
+ /// Meshes at this node
+ std::vector<MeshInstance> mMeshes;
+
+ /// Lights at this node
+ std::vector<LightInstance> mLights;
+
+ /// Cameras at this node
+ std::vector<CameraInstance> mCameras;
+
+ /// Node instances at this node
+ std::vector<NodeInstance> 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<Node *>::iterator it = mChildren.begin(); it != mChildren.end(); ++it) {
+ delete *it;
+ }
+ }
+};
+
+/// Data source array: either floats or strings
+struct Data {
+ bool mIsStringArray;
+ std::vector<ai_real> mValues;
+ std::vector<std::string> 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<std::string> 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<size_t> 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<InputChannel> mPerVertexData;
+
+ // actual mesh data, assembled on encounter of a <p> element. Verbose format, not indexed
+ std::vector<aiVector3D> mPositions;
+ std::vector<aiVector3D> mNormals;
+ std::vector<aiVector3D> mTangents;
+ std::vector<aiVector3D> mBitangents;
+ std::vector<aiVector3D> mTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
+ std::vector<aiColor4D> 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<size_t> mFaceSize;
+
+ // Position indices for all faces in the sequence given in mFaceSize -
+ // necessary for bone weight assignment
+ std::vector<size_t> mFacePosIndices;
+
+ // Sub-meshes in this mesh, each with a given material
+ std::vector<SubMesh> 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<size_t> mWeightCounts;
+
+ // JointIndex-WeightIndex pairs for all vertices
+ std::vector<std::pair<size_t, size_t>> 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<std::string, Collada::EffectParam>;
+ 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<uint8_t> 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<AnimationChannel> mChannels;
+
+ /// the sub-animations, if any
+ std::vector<Animation *> mSubAnims;
+
+ /// Destructor
+ ~Animation() {
+ for (std::vector<Animation *>::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<AnimationChannel> &channels) {
+ channels.insert(channels.end(), mChannels.begin(), mChannels.end());
+
+ for (std::vector<Animation *>::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<std::string> childrenTargets;
+ bool childrenAnimationsHaveDifferentChannels = true;
+
+ for (std::vector<Animation *>::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<Animation *>::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/libs/assimp/code/AssetLib/Collada/ColladaLoader.cpp b/libs/assimp/code/AssetLib/Collada/ColladaLoader.cpp
new file mode 100644
index 0000000..775ba44
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaLoader.cpp
@@ -0,0 +1,1828 @@
+/*
+---------------------------------------------------------------------------
+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 <assimp/ColladaMetaData.h>
+#include <assimp/CreateAnimMesh.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/anim.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Importer.hpp>
+
+#include <numeric>
+
+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 <typename T>
+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[] = { "<collada" };
+ return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+void ColladaLoader::SetupProperties(const Importer *pImp) {
+ noSkeletonMesh = pImp->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<unsigned int>(numMeta));
+ size_t i = 0;
+ for (auto it = parser.mAssetMetaData.cbegin(); it != parser.mAssetMetaData.cend(); ++it, ++i) {
+ pScene->mMetaData->Set(static_cast<unsigned int>(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<const Node*> instances;
+ ResolveNodeInstances(pParser, pNode, instances);
+
+ // add children. first the *real* ones
+ node->mNumChildren = static_cast<unsigned int>(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<const Node*> &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<size_t> 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<std::string, SemanticMappingTable>::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<std::string, size_t>::const_iterator matIt = mMaterialIndexByName.find(meshMaterial);
+ unsigned int matIdx = 0;
+ if (matIt != mMaterialIndexByName.end()) {
+ matIdx = static_cast<unsigned int>(matIt->second);
+ }
+
+ if (table && !table->mMap.empty()) {
+ std::pair<Collada::Effect *, aiMaterial *> &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<ColladaMeshIndex, size_t>::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<std::string, size_t>::const_iterator subMatIt = mMaterialIndexByName.find(submesh.mMaterial);
+ if (subMatIt != mMaterialIndexByName.end()) {
+ dstMesh->mMaterialIndex = static_cast<unsigned int>(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<unsigned int>(newMeshRefs.size());
+ if (!newMeshRefs.empty()) {
+ struct UIntTypeConverter {
+ unsigned int operator()(const size_t &v) const {
+ return static_cast<unsigned int>(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<aiMesh> 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<unsigned int>(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<unsigned int>(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<unsigned int>(s);
+ face.mIndices = new unsigned int[s];
+ for (size_t b = 0; b < s; ++b) {
+ face.mIndices[b] = static_cast<unsigned int>(vertex++);
+ }
+ }
+
+ // create morph target meshes if any
+ std::vector<aiMesh *> targetMeshes;
+ std::vector<float> targetWeights;
+ Collada::MorphMethod method = Normalized;
+
+ for (std::map<std::string, Controller>::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<aiAnimMesh *> 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<unsigned int>(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<std::vector<aiVertexWeight>> dstBones(numBones);
+
+ // build a temporary array of pointers to the start of each vertex's weights
+ using IndexPairVector = std::vector<std::pair<size_t, size_t>>;
+ std::vector<IndexPairVector::const_iterator> 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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<unsigned int>(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<size_t> 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<std::string> 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<unsigned int>(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<unsigned int>(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<key> mKeys;
+};
+
+void insertMorphTimeValue(std::vector<MorphTimeValues> &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<MorphTimeValues> &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<const aiNode *> nodes;
+ CollectNodes(pScene->mRootNode, nodes);
+
+ std::vector<aiNodeAnim *> anims;
+ std::vector<aiMeshMorphAnim *> morphAnims;
+
+ for (auto node : nodes) {
+ // find all the collada anim channels which refer to the current node
+ std::vector<ChannelEntry> 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<AnimationChannel>::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<aiMatrix4x4> resultTrafos;
+ if (!entries.empty() && entries.front().mTimeAccessor->mCount > 0) {
+ // create a local transformation chain of the node's transforms
+ std::vector<Collada::Transform> 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<int>(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<unsigned int>(resultTrafos.size());
+ dstAnim->mNumRotationKeys = static_cast<unsigned int>(resultTrafos.size());
+ dstAnim->mNumScalingKeys = static_cast<unsigned int>(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<ChannelEntry> 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> 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<unsigned int>(morphTimeValues.size());
+ morphAnim->mKeys = new aiMeshMorphKey[morphAnim->mNumKeys];
+ for (unsigned int key = 0; key < morphAnim->mNumKeys; key++) {
+ morphAnim->mKeys[key].mNumValuesAndWeights = static_cast<unsigned int>(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<unsigned int>(anims.size());
+ if (anim->mNumChannels > 0) {
+ anim->mChannels = new aiNodeAnim *[anims.size()];
+ std::copy(anims.begin(), anims.end(), anim->mChannels);
+ }
+ anim->mNumMorphMeshChannels = static_cast<unsigned int>(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<int>(&shadeMode, 1, AI_MATKEY_SHADING_MODEL);
+
+ // double-sided?
+ shadeMode = effect.mDoubleSided;
+ mat.AddProperty<int>(&shadeMode, 1, AI_MATKEY_TWOSIDED);
+
+ // wire-frame?
+ shadeMode = effect.mWireframe;
+ mat.AddProperty<int>(&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<unsigned int>(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<const aiNode *> &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/libs/assimp/code/AssetLib/Collada/ColladaLoader.h b/libs/assimp/code/AssetLib/Collada/ColladaLoader.h
new file mode 100644
index 0000000..246abed
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaLoader.h
@@ -0,0 +1,249 @@
+/** 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 <assimp/BaseImporter.h>
+
+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<const Collada::Node *> &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<const aiNode *> &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<ColladaMeshIndex, size_t> mMeshIndexByID;
+
+ /** Which material was stored under which index in the scene */
+ std::map<std::string, size_t> mMaterialIndexByName;
+
+ /** Accumulated meshes for the target scene */
+ std::vector<aiMesh *> mMeshes;
+
+ /** Accumulated morph target meshes */
+ std::vector<aiMesh *> mTargetMeshes;
+
+ /** Temporary material list */
+ std::vector<std::pair<Collada::Effect *, aiMaterial *>> newMats;
+
+ /** Temporary camera list */
+ std::vector<aiCamera *> mCameras;
+
+ /** Temporary light list */
+ std::vector<aiLight *> mLights;
+
+ /** Temporary texture list */
+ std::vector<aiTexture *> mTextures;
+
+ /** Accumulated animations for the target scene */
+ std::vector<aiAnimation *> 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/libs/assimp/code/AssetLib/Collada/ColladaParser.cpp b/libs/assimp/code/AssetLib/Collada/ColladaParser.cpp
new file mode 100644
index 0000000..922d1f6
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaParser.cpp
@@ -0,0 +1,2402 @@
+/*
+---------------------------------------------------------------------------
+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 <assimp/ParsingUtils.h>
+#include <assimp/StringUtils.h>
+#include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/light.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <memory>
+
+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<size_t>::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<IOStream> daefile;
+ std::unique_ptr<ZipArchiveIOSystem> 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<IOStream> manifestfile(zip_archive.Open("manifest.xml"));
+ if (manifestfile == nullptr) {
+ // No manifest, hope there is only one .DAE inside
+ std::vector<std::string> 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<ai_uint32>(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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = currentNode.name();
+ if (currentName == "unit") {
+ mUnitSize = 1.f;
+ std::string tUnitSizeString;
+ if (XmlParser::getStdStrAttribute(currentNode, "meter", tUnitSizeString)) {
+ try {
+ fast_atoreal_move<ai_real>(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<std::string, std::vector<std::string>> clip;
+ clip.first = animName;
+
+ for (XmlNode &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 <animation> 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<std::string, AnimationChannel>;
+ 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentName = 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<ai_real>(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 &currentChildName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 <joints> data <input> 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 <joints> data <input> 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 <vertex_weights> data <input> 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 <vertex_weights> data <input> element");
+ }
+ } else if (currentName == "vcount" && vertexCount > 0) {
+ const char *text = currentNode.text().as_string();
+ size_t numWeights = 0;
+ for (std::vector<size_t>::iterator it = pController.mWeightCounts.begin(); it != pController.mWeightCounts.end(); ++it) {
+ if (*text == 0) {
+ throw DeadlyImportError("Out of data while reading <vcount>");
+ }
+
+ *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<std::pair<size_t, size_t>>::iterator it = pController.mWeights.begin(); it != pController.mWeights.end(); ++it) {
+ if (text == 0) {
+ throw DeadlyImportError("Out of data while reading <vertex_weights>");
+ }
+ it->first = strtoul10(text, &text);
+ SkipSpacesAndLineEnd(&text);
+ if (*text == 0) {
+ throw DeadlyImportError("Out of data while reading <vertex_weights>");
+ }
+ it->second = strtoul10(text, &text);
+ SkipSpacesAndLineEnd(&text);
+ }
+ }
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the image library contents
+void ColladaParser::ReadImageLibrary(XmlNode &node) {
+ for (XmlNode &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : 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 <init_from/> 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<std::string, int> names;
+ for (XmlNode &currentNode : 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<std::string, int>::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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentName = 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<ai_real>(content, (ai_real &)pLight.mColor.r);
+ SkipSpacesAndLineEnd(&content);
+
+ content = fast_atoreal_move<ai_real>(content, (ai_real &)pLight.mColor.g);
+ SkipSpacesAndLineEnd(&content);
+
+ content = fast_atoreal_move<ai_real>(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 &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentName = 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 &currentName = 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<ai_real>(content, (ai_real &)pColor.r);
+ SkipSpacesAndLineEnd(&content);
+
+ content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.g);
+ SkipSpacesAndLineEnd(&content);
+
+ content = fast_atoreal_move<ai_real>(content, (ai_real &)pColor.b);
+ SkipSpacesAndLineEnd(&content);
+
+ content = fast_atoreal_move<ai_real>(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 &currentName = currentNode.name();
+ if (currentName == "surface") {
+ // image ID given inside <init_from> 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 <source> tags
+ const char *content = currentNode.value();
+ pParam.mType = Param_Sampler;
+ pParam.mReference = content;
+ } else if (currentName == "sampler2D") {
+ // surface ID is given inside <instance_image> 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 &currentNode : node.children()) {
+ const std::string &currentName = 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> 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 &currentName = 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 &currentName = 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<ai_real>(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 <accessor> 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 &currentName = 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 <vertices> element. Not that we care, but to catch strange referencing schemes we should warn about
+ XmlParser::getStdStrAttribute(node, "id", pMesh.mVertexID);
+ for (XmlNode &currentNode : node.children()) {
+ const std::string &currentName = currentNode.name();
+ if (currentName == "input") {
+ ReadInputChannel(currentNode, pMesh.mPerVertexData);
+ } else {
+ throw DeadlyImportError("Unexpected sub element <", currentName, "> in tag <vertices>");
+ }
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads input declarations of per-index mesh data into the given mesh
+void ColladaParser::ReadIndexData(XmlNode &node, Mesh &pMesh) {
+ std::vector<size_t> vcount;
+ std::vector<InputChannel> 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 <p>-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 <input> elements, but in addition a <p> primitive collection and probably index counts for all primitives
+ XmlNodeIterator xmlIt(node, XmlNodeIterator::PreOrderMode);
+ XmlNode currentNode;
+ while (xmlIt.getNext(currentNode)) {
+ const std::string &currentName = 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 <polylist> - 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 <vcount> 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 <p> 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<InputChannel> &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 <input> 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 <input>
+ 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 <p> primitive index list and assembles the mesh data into the given mesh
+size_t ColladaParser::ReadPrimitives(XmlNode &node, Mesh &pMesh, std::vector<InputChannel> &pPerIndexChannels,
+ size_t pNumPrimitives, const std::vector<size_t> &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<size_t> 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 <p> element, %zu instead of %zu.", indices.size(), expectedPointCount * numOffsets);
+ pNumPrimitives = (indices.size() / numOffsets) / 2;
+ } else {
+ throw DeadlyImportError("Expected different index count in <p> element.");
+ }
+ } else if (expectedPointCount == 0 && (indices.size() % numOffsets) != 0) {
+ throw DeadlyImportError("Expected different index count in <p> element.");
+ }
+
+ // find the data for all sources
+ for (std::vector<InputChannel>::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<InputChannel>::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 <vertices> 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 <p>, but only one primitive per <p>
+ size_t numPrimitives = pNumPrimitives;
+ if (pPrimType == Prim_TriFans || pPrimType == Prim_Polygon)
+ numPrimitives = 1;
+ // For continued primitives, the given count is actually the number of <p>'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 <vertices> and <polylist> 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<InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &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<InputChannel>::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<InputChannel>::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<InputChannel> &pPerIndexChannels,
+ size_t currentPrimitive, const std::vector<size_t> &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<unsigned int>(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 &currentNode : node.children()) {
+ const std::string &currentName = 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 <bla/> elements
+ if (node.empty()) {
+ return;
+ }
+
+ for (XmlNode &currentNode : node.children()) {
+ const std::string &currentName = 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 <library_nodes> 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 <instance_light> 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 <instance_camera> 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<ai_real>(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 &currentNode : node.children()) {
+ const std::string &currentName = 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 <bind> 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<IOStream> 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 <instance_geometry> 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 &currentName = 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 &currentNode : node.children()) {
+ const std::string &currentName = 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 <instance_visual_scene> 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 <instance_visual_scene> 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 <instance_visual_scene> element.");
+ }
+ mRootNode = sit->second;
+ }
+ }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Calculates the resulting transformation from all the given transform steps
+aiMatrix4x4 ColladaParser::CalculateResultTransform(const std::vector<Transform> &pTransforms) const {
+ aiMatrix4x4 res;
+
+ for (std::vector<Transform>::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/libs/assimp/code/AssetLib/Collada/ColladaParser.h b/libs/assimp/code/AssetLib/Collada/ColladaParser.h
new file mode 100644
index 0000000..1598293
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Collada/ColladaParser.h
@@ -0,0 +1,348 @@
+/*
+ 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 <assimp/TinyFormatter.h>
+#include <assimp/ai_assert.h>
+#include <assimp/XmlParser.h>
+
+#include <map>
+
+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<std::string, aiString> 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 <source> 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<Collada::InputChannel> &poChannels);
+
+ /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
+ size_t ReadPrimitives(XmlNode &node, Collada::Mesh &pMesh, std::vector<Collada::InputChannel> &pPerIndexChannels,
+ size_t pNumPrimitives, const std::vector<size_t> &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<Collada::InputChannel> &pPerIndexChannels,
+ size_t currentPrimitive, const std::vector<size_t> &indices);
+
+ /** Reads one triangle of a tristrip into the mesh */
+ void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh &pMesh,
+ std::vector<Collada::InputChannel> &pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t> &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<Collada::Transform> &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 <typename Type>
+ const Type &ResolveLibraryReference(const std::map<std::string, Type> &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<std::string, Collada::Data> ;
+ DataLibrary mDataLibrary;
+
+ /** Same for accessors which define how the data in a data array is accessed. */
+ using AccessorLibrary = std::map<std::string, Collada::Accessor> ;
+ AccessorLibrary mAccessorLibrary;
+
+ /** Mesh library: mesh by ID */
+ using MeshLibrary = std::map<std::string, Collada::Mesh *>;
+ MeshLibrary mMeshLibrary;
+
+ /** node library: root node of the hierarchy part by ID */
+ using NodeLibrary = std::map<std::string, Collada::Node *>;
+ NodeLibrary mNodeLibrary;
+
+ /** Image library: stores texture properties by ID */
+ using ImageLibrary = std::map<std::string, Collada::Image> ;
+ ImageLibrary mImageLibrary;
+
+ /** Effect library: surface attributes by ID */
+ using EffectLibrary = std::map<std::string, Collada::Effect> ;
+ EffectLibrary mEffectLibrary;
+
+ /** Material library: surface material by ID */
+ using MaterialLibrary = std::map<std::string, Collada::Material> ;
+ MaterialLibrary mMaterialLibrary;
+
+ /** Light library: surface light by ID */
+ using LightLibrary = std::map<std::string, Collada::Light> ;
+ LightLibrary mLightLibrary;
+
+ /** Camera library: surface material by ID */
+ using CameraLibrary = std::map<std::string, Collada::Camera> ;
+ CameraLibrary mCameraLibrary;
+
+ /** Controller library: joint controllers by ID */
+ using ControllerLibrary = std::map<std::string, Collada::Controller> ;
+ ControllerLibrary mControllerLibrary;
+
+ /** Animation library: animation references by ID */
+ using AnimationLibrary = std::map<std::string, Collada::Animation *> ;
+ AnimationLibrary mAnimationLibrary;
+
+ /** Animation clip library: clip animation references by ID */
+ using AnimationClipLibrary = std::vector<std::pair<std::string, std::vector<std::string>>> ;
+ 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 <typename Type>
+const Type &ColladaParser::ResolveLibraryReference(const std::map<std::string, Type> &pLibrary, const std::string &pURL) const {
+ typename std::map<std::string, Type>::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