move 3rd-party librarys into libs/ and add built-in honeysuckle

6 files changed, 2745 insertions, 0 deletions

diff --git a/libs/assimp/code/AssetLib/Irr/IRRLoader.cpp b/libs/assimp/code/AssetLib/Irr/IRRLoader.cpp
new file mode 100644
index 0000000..0061634
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Irr/IRRLoader.cpp
@@ -0,0 +1,1359 @@
+/*
+---------------------------------------------------------------------------
+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  IRRLoader.cpp
+ *  @brief Implementation of the Irr importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
+
+#include "AssetLib/Irr/IRRLoader.h"
+#include "Common/Importer.h"
+
+#include <assimp/GenericProperty.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StandardShapes.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <memory>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+	"Irrlicht Scene Reader",
+	"",
+	"",
+	"http://irrlicht.sourceforge.net/",
+	aiImporterFlags_SupportTextFlavour,
+	0,
+	0,
+	0,
+	0,
+	"irr xml"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+IRRImporter::IRRImporter() :
+		fps(), configSpeedFlag() {
+	// empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+IRRImporter::~IRRImporter() {
+	// empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool IRRImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+	static const char *tokens[] = { "irr_scene" };
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *IRRImporter::GetInfo() const {
+	return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::SetupProperties(const Importer *pImp) {
+	// read the output frame rate of all node animation channels
+	fps = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IRR_ANIM_FPS, 100);
+	if (fps < 10.) {
+		ASSIMP_LOG_ERROR("IRR: Invalid FPS configuration");
+		fps = 100;
+	}
+
+	// AI_CONFIG_FAVOUR_SPEED
+	configSpeedFlag = (0 != pImp->GetPropertyInteger(AI_CONFIG_FAVOUR_SPEED, 0));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Build a mesh that consists of a single squad (a side of a skybox)
+aiMesh *IRRImporter::BuildSingleQuadMesh(const SkyboxVertex &v1,
+		const SkyboxVertex &v2,
+		const SkyboxVertex &v3,
+		const SkyboxVertex &v4) {
+	// allocate and prepare the mesh
+	aiMesh *out = new aiMesh();
+
+	out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
+	out->mNumFaces = 1;
+
+	// build the face
+	out->mFaces = new aiFace[1];
+	aiFace &face = out->mFaces[0];
+
+	face.mNumIndices = 4;
+	face.mIndices = new unsigned int[4];
+	for (unsigned int i = 0; i < 4; ++i)
+		face.mIndices[i] = i;
+
+	out->mNumVertices = 4;
+
+	// copy vertex positions
+	aiVector3D *vec = out->mVertices = new aiVector3D[4];
+	*vec++ = v1.position;
+	*vec++ = v2.position;
+	*vec++ = v3.position;
+	*vec = v4.position;
+
+	// copy vertex normals
+	vec = out->mNormals = new aiVector3D[4];
+	*vec++ = v1.normal;
+	*vec++ = v2.normal;
+	*vec++ = v3.normal;
+	*vec = v4.normal;
+
+	// copy texture coordinates
+	vec = out->mTextureCoords[0] = new aiVector3D[4];
+	*vec++ = v1.uv;
+	*vec++ = v2.uv;
+	*vec++ = v3.uv;
+	*vec = v4.uv;
+	return out;
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::BuildSkybox(std::vector<aiMesh *> &meshes, std::vector<aiMaterial *> materials) {
+	// Update the material of the skybox - replace the name and disable shading for skyboxes.
+	for (unsigned int i = 0; i < 6; ++i) {
+		aiMaterial *out = (aiMaterial *)(*(materials.end() - (6 - i)));
+
+		aiString s;
+		s.length = ::ai_snprintf(s.data, MAXLEN, "SkyboxSide_%u", i);
+		out->AddProperty(&s, AI_MATKEY_NAME);
+
+		int shading = aiShadingMode_NoShading;
+		out->AddProperty(&shading, 1, AI_MATKEY_SHADING_MODEL);
+	}
+
+	// Skyboxes are much more difficult. They are represented
+	// by six single planes with different textures, so we'll
+	// need to build six meshes.
+
+	const ai_real l = 10.0; // the size used by Irrlicht
+
+	// FRONT SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(-l, -l, -l, 0, 0, 1, 1.0, 1.0),
+			SkyboxVertex(l, -l, -l, 0, 0, 1, 0.0, 1.0),
+			SkyboxVertex(l, l, -l, 0, 0, 1, 0.0, 0.0),
+			SkyboxVertex(-l, l, -l, 0, 0, 1, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 6u);
+
+	// LEFT SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, -l, -l, -1, 0, 0, 1.0, 1.0),
+			SkyboxVertex(l, -l, l, -1, 0, 0, 0.0, 1.0),
+			SkyboxVertex(l, l, l, -1, 0, 0, 0.0, 0.0),
+			SkyboxVertex(l, l, -l, -1, 0, 0, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 5u);
+
+	// BACK SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, -l, l, 0, 0, -1, 1.0, 1.0),
+			SkyboxVertex(-l, -l, l, 0, 0, -1, 0.0, 1.0),
+			SkyboxVertex(-l, l, l, 0, 0, -1, 0.0, 0.0),
+			SkyboxVertex(l, l, l, 0, 0, -1, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 4u);
+
+	// RIGHT SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(-l, -l, l, 1, 0, 0, 1.0, 1.0),
+			SkyboxVertex(-l, -l, -l, 1, 0, 0, 0.0, 1.0),
+			SkyboxVertex(-l, l, -l, 1, 0, 0, 0.0, 0.0),
+			SkyboxVertex(-l, l, l, 1, 0, 0, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 3u);
+
+	// TOP SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, l, -l, 0, -1, 0, 1.0, 1.0),
+			SkyboxVertex(l, l, l, 0, -1, 0, 0.0, 1.0),
+			SkyboxVertex(-l, l, l, 0, -1, 0, 0.0, 0.0),
+			SkyboxVertex(-l, l, -l, 0, -1, 0, 1.0, 0.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 2u);
+
+	// BOTTOM SIDE
+	meshes.push_back(BuildSingleQuadMesh(
+			SkyboxVertex(l, -l, l, 0, 1, 0, 0.0, 0.0),
+			SkyboxVertex(l, -l, -l, 0, 1, 0, 1.0, 0.0),
+			SkyboxVertex(-l, -l, -l, 0, 1, 0, 1.0, 1.0),
+			SkyboxVertex(-l, -l, l, 0, 1, 0, 0.0, 1.0)));
+	meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size() - 1u);
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::CopyMaterial(std::vector<aiMaterial *> &materials,
+		std::vector<std::pair<aiMaterial *, unsigned int>> &inmaterials,
+		unsigned int &defMatIdx,
+		aiMesh *mesh) {
+	if (inmaterials.empty()) {
+		// Do we have a default material? If not we need to create one
+		if (UINT_MAX == defMatIdx) {
+			defMatIdx = (unsigned int)materials.size();
+			//TODO: add this materials to someone?
+			/*aiMaterial* mat = new aiMaterial();
+
+            aiString s;
+            s.Set(AI_DEFAULT_MATERIAL_NAME);
+            mat->AddProperty(&s,AI_MATKEY_NAME);
+
+            aiColor3D c(0.6f,0.6f,0.6f);
+            mat->AddProperty(&c,1,AI_MATKEY_COLOR_DIFFUSE);*/
+		}
+		mesh->mMaterialIndex = defMatIdx;
+		return;
+	} else if (inmaterials.size() > 1) {
+		ASSIMP_LOG_INFO("IRR: Skipping additional materials");
+	}
+
+	mesh->mMaterialIndex = (unsigned int)materials.size();
+	materials.push_back(inmaterials[0].first);
+}
+
+// ------------------------------------------------------------------------------------------------
+inline int ClampSpline(int idx, int size) {
+	return (idx < 0 ? size + idx : (idx >= size ? idx - size : idx));
+}
+
+// ------------------------------------------------------------------------------------------------
+inline void FindSuitableMultiple(int &angle) {
+	if (angle < 3)
+		angle = 3;
+	else if (angle < 10)
+		angle = 10;
+	else if (angle < 20)
+		angle = 20;
+	else if (angle < 30)
+		angle = 30;
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::ComputeAnimations(Node *root, aiNode *real, std::vector<aiNodeAnim *> &anims) {
+	ai_assert(nullptr != root && nullptr != real);
+
+	// XXX totally WIP - doesn't produce proper results, need to evaluate
+	// whether there's any use for Irrlicht's proprietary scene format
+	// outside Irrlicht ...
+	// This also applies to the above function of FindSuitableMultiple and ClampSpline which are
+	// solely used in this function
+
+	if (root->animators.empty()) {
+		return;
+	}
+	unsigned int total(0);
+	for (std::list<Animator>::iterator it = root->animators.begin(); it != root->animators.end(); ++it) {
+		if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) {
+			ASSIMP_LOG_WARN("IRR: Skipping unknown or unsupported animator");
+			continue;
+		}
+		++total;
+	}
+	if (!total) {
+		return;
+	} else if (1 == total) {
+		ASSIMP_LOG_WARN("IRR: Adding dummy nodes to simulate multiple animators");
+	}
+
+	// NOTE: 1 tick == i millisecond
+
+	unsigned int cur = 0;
+	for (std::list<Animator>::iterator it = root->animators.begin();
+			it != root->animators.end(); ++it) {
+		if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) continue;
+
+		Animator &in = *it;
+		aiNodeAnim *anim = new aiNodeAnim();
+
+		if (cur != total - 1) {
+			// Build a new name - a prefix instead of a suffix because it is
+			// easier to check against
+			anim->mNodeName.length = ::ai_snprintf(anim->mNodeName.data, MAXLEN,
+					"$INST_DUMMY_%i_%s", total - 1,
+					(root->name.length() ? root->name.c_str() : ""));
+
+			// we'll also need to insert a dummy in the node hierarchy.
+			aiNode *dummy = new aiNode();
+
+			for (unsigned int i = 0; i < real->mParent->mNumChildren; ++i)
+				if (real->mParent->mChildren[i] == real)
+					real->mParent->mChildren[i] = dummy;
+
+			dummy->mParent = real->mParent;
+			dummy->mName = anim->mNodeName;
+
+			dummy->mNumChildren = 1;
+			dummy->mChildren = new aiNode *[dummy->mNumChildren];
+			dummy->mChildren[0] = real;
+
+			// the transformation matrix of the dummy node is the identity
+
+			real->mParent = dummy;
+		} else
+			anim->mNodeName.Set(root->name);
+		++cur;
+
+		switch (in.type) {
+			case Animator::ROTATION: {
+				// -----------------------------------------------------
+				// find out how long a full rotation will take
+				// This is the least common multiple of 360.f and all
+				// three euler angles. Although we'll surely find a
+				// possible multiple (haha) it could be somewhat large
+				// for our purposes. So we need to modify the angles
+				// here in order to get good results.
+				// -----------------------------------------------------
+				int angles[3];
+				angles[0] = (int)(in.direction.x * 100);
+				angles[1] = (int)(in.direction.y * 100);
+				angles[2] = (int)(in.direction.z * 100);
+
+				angles[0] %= 360;
+				angles[1] %= 360;
+				angles[2] %= 360;
+
+				if ((angles[0] * angles[1]) != 0 && (angles[1] * angles[2]) != 0) {
+					FindSuitableMultiple(angles[0]);
+					FindSuitableMultiple(angles[1]);
+					FindSuitableMultiple(angles[2]);
+				}
+
+				int lcm = 360;
+
+				if (angles[0])
+					lcm = Math::lcm(lcm, angles[0]);
+
+				if (angles[1])
+					lcm = Math::lcm(lcm, angles[1]);
+
+				if (angles[2])
+					lcm = Math::lcm(lcm, angles[2]);
+
+				if (360 == lcm)
+					break;
+
+
+				// find out how many time units we'll need for the finest
+				// track (in seconds) - this defines the number of output
+				// keys (fps * seconds)
+				float max = 0.f;
+				if (angles[0])
+					max = (float)lcm / angles[0];
+				if (angles[1])
+					max = std::max(max, (float)lcm / angles[1]);
+				if (angles[2])
+					max = std::max(max, (float)lcm / angles[2]);
+
+				anim->mNumRotationKeys = (unsigned int)(max * fps);
+				anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys];
+
+				// begin with a zero angle
+				aiVector3D angle;
+				for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
+					// build the quaternion for the given euler angles
+					aiQuatKey &q = anim->mRotationKeys[i];
+
+					q.mValue = aiQuaternion(angle.x, angle.y, angle.z);
+					q.mTime = (double)i;
+
+					// increase the angle
+					angle += in.direction;
+				}
+
+				// This animation is repeated and repeated ...
+				anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
+			} break;
+
+			case Animator::FLY_CIRCLE: {
+				// -----------------------------------------------------
+				// Find out how much time we'll need to perform a
+				// full circle.
+				// -----------------------------------------------------
+				const double seconds = (1. / in.speed) / 1000.;
+				const double tdelta = 1000. / fps;
+
+				anim->mNumPositionKeys = (unsigned int)(fps * seconds);
+				anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+				// from Irrlicht, what else should we do than copying it?
+				aiVector3D vecU, vecV;
+				if (in.direction.y) {
+					vecV = aiVector3D(50, 0, 0) ^ in.direction;
+				} else
+					vecV = aiVector3D(0, 50, 00) ^ in.direction;
+				vecV.Normalize();
+				vecU = (vecV ^ in.direction).Normalize();
+
+				// build the output keys
+				for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+					aiVectorKey &key = anim->mPositionKeys[i];
+					key.mTime = i * tdelta;
+
+					const ai_real t = (ai_real)(in.speed * key.mTime);
+					key.mValue = in.circleCenter + in.circleRadius * ((vecU * std::cos(t)) + (vecV * std::sin(t)));
+				}
+
+				// This animation is repeated and repeated ...
+				anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
+			} break;
+
+			case Animator::FLY_STRAIGHT: {
+				anim->mPostState = anim->mPreState = (in.loop ? aiAnimBehaviour_REPEAT : aiAnimBehaviour_CONSTANT);
+				const double seconds = in.timeForWay / 1000.;
+				const double tdelta = 1000. / fps;
+
+				anim->mNumPositionKeys = (unsigned int)(fps * seconds);
+				anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+				aiVector3D diff = in.direction - in.circleCenter;
+				const ai_real lengthOfWay = diff.Length();
+				diff.Normalize();
+
+				const double timeFactor = lengthOfWay / in.timeForWay;
+
+				// build the output keys
+				for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+					aiVectorKey &key = anim->mPositionKeys[i];
+					key.mTime = i * tdelta;
+					key.mValue = in.circleCenter + diff * ai_real(timeFactor * key.mTime);
+				}
+			} break;
+
+			case Animator::FOLLOW_SPLINE: {
+				// repeat outside the defined time range
+				anim->mPostState = anim->mPreState = aiAnimBehaviour_REPEAT;
+				const int size = (int)in.splineKeys.size();
+				if (!size) {
+					// We have no point in the spline. That's bad. Really bad.
+					ASSIMP_LOG_WARN("IRR: Spline animators with no points defined");
+
+					delete anim;
+					anim = nullptr;
+					break;
+				} else if (size == 1) {
+					// We have just one point in the spline so we don't need the full calculation
+					anim->mNumPositionKeys = 1;
+					anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+					anim->mPositionKeys[0].mValue = in.splineKeys[0].mValue;
+					anim->mPositionKeys[0].mTime = 0.f;
+					break;
+				}
+
+				unsigned int ticksPerFull = 15;
+				anim->mNumPositionKeys = (unsigned int)(ticksPerFull * fps);
+				anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys];
+
+				for (unsigned int i = 0; i < anim->mNumPositionKeys; ++i) {
+					aiVectorKey &key = anim->mPositionKeys[i];
+
+					const ai_real dt = (i * in.speed * ai_real(0.001));
+					const ai_real u = dt - std::floor(dt);
+					const int idx = (int)std::floor(dt) % size;
+
+					// get the 4 current points to evaluate the spline
+					const aiVector3D &p0 = in.splineKeys[ClampSpline(idx - 1, size)].mValue;
+					const aiVector3D &p1 = in.splineKeys[ClampSpline(idx + 0, size)].mValue;
+					const aiVector3D &p2 = in.splineKeys[ClampSpline(idx + 1, size)].mValue;
+					const aiVector3D &p3 = in.splineKeys[ClampSpline(idx + 2, size)].mValue;
+
+					// compute polynomials
+					const ai_real u2 = u * u;
+					const ai_real u3 = u2 * 2;
+
+					const ai_real h1 = ai_real(2.0) * u3 - ai_real(3.0) * u2 + ai_real(1.0);
+					const ai_real h2 = ai_real(-2.0) * u3 + ai_real(3.0) * u3;
+					const ai_real h3 = u3 - ai_real(2.0) * u3;
+					const ai_real h4 = u3 - u2;
+
+					// compute the spline tangents
+					const aiVector3D t1 = (p2 - p0) * in.tightness;
+					aiVector3D t2 = (p3 - p1) * in.tightness;
+
+					// and use them to get the interpolated point
+					t2 = (h1 * p1 + p2 * h2 + t1 * h3 + h4 * t2);
+
+					// build a simple translation matrix from it
+					key.mValue = t2;
+					key.mTime = (double)i;
+				}
+			} break;
+			default:
+				// UNKNOWN , OTHER
+				break;
+		};
+		if (anim) {
+			anims.push_back(anim);
+			++total;
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// This function is maybe more generic than we'd need it here
+void SetupMapping(aiMaterial *mat, aiTextureMapping mode, const aiVector3D &axis = aiVector3D(0.f, 0.f, -1.f)) {
+	if (nullptr == mat) {
+		return;
+	}
+
+    // Check whether there are texture properties defined - setup
+	// the desired texture mapping mode for all of them and ignore
+	// all UV settings we might encounter. WE HAVE NO UVS!
+
+	std::vector<aiMaterialProperty *> p;
+	p.reserve(mat->mNumProperties + 1);
+
+	for (unsigned int i = 0; i < mat->mNumProperties; ++i) {
+		aiMaterialProperty *prop = mat->mProperties[i];
+		if (!::strcmp(prop->mKey.data, "$tex.file")) {
+			// Setup the mapping key
+			aiMaterialProperty *m = new aiMaterialProperty();
+			m->mKey.Set("$tex.mapping");
+			m->mIndex = prop->mIndex;
+			m->mSemantic = prop->mSemantic;
+			m->mType = aiPTI_Integer;
+
+			m->mDataLength = 4;
+			m->mData = new char[4];
+			*((int *)m->mData) = mode;
+
+			p.push_back(prop);
+			p.push_back(m);
+
+			// Setup the mapping axis
+			if (mode == aiTextureMapping_CYLINDER || mode == aiTextureMapping_PLANE || mode == aiTextureMapping_SPHERE) {
+				m = new aiMaterialProperty();
+				m->mKey.Set("$tex.mapaxis");
+				m->mIndex = prop->mIndex;
+				m->mSemantic = prop->mSemantic;
+				m->mType = aiPTI_Float;
+
+				m->mDataLength = 12;
+				m->mData = new char[12];
+				*((aiVector3D *)m->mData) = axis;
+				p.push_back(m);
+			}
+		} else if (!::strcmp(prop->mKey.data, "$tex.uvwsrc")) {
+			delete mat->mProperties[i];
+		} else
+			p.push_back(prop);
+	}
+
+	if (p.empty()) return;
+
+	// rebuild the output array
+	if (p.size() > mat->mNumAllocated) {
+		delete[] mat->mProperties;
+		mat->mProperties = new aiMaterialProperty *[p.size() * 2];
+
+		mat->mNumAllocated = static_cast<unsigned int>(p.size() * 2);
+	}
+	mat->mNumProperties = (unsigned int)p.size();
+	::memcpy(mat->mProperties, &p[0], sizeof(void *) * mat->mNumProperties);
+}
+
+// ------------------------------------------------------------------------------------------------
+void IRRImporter::GenerateGraph(Node *root, aiNode *rootOut, aiScene *scene,
+		BatchLoader &batch,
+		std::vector<aiMesh *> &meshes,
+		std::vector<aiNodeAnim *> &anims,
+		std::vector<AttachmentInfo> &attach,
+		std::vector<aiMaterial *> &materials,
+		unsigned int &defMatIdx) {
+	unsigned int oldMeshSize = (unsigned int)meshes.size();
+	//unsigned int meshTrafoAssign = 0;
+
+	// Now determine the type of the node
+	switch (root->type) {
+		case Node::ANIMMESH:
+		case Node::MESH: {
+			if (!root->meshPath.length())
+				break;
+
+			// Get the loaded mesh from the scene and add it to
+			// the list of all scenes to be attached to the
+			// graph we're currently building
+			aiScene *localScene = batch.GetImport(root->id);
+			if (!localScene) {
+				ASSIMP_LOG_ERROR("IRR: Unable to load external file: ", root->meshPath);
+				break;
+			}
+			attach.push_back(AttachmentInfo(localScene, rootOut));
+
+			// Now combine the material we've loaded for this mesh
+			// with the real materials we got from the file. As we
+			// don't execute any pp-steps on the file, the numbers
+			// should be equal. If they are not, we can impossibly
+			// do this  ...
+			if (root->materials.size() != (unsigned int)localScene->mNumMaterials) {
+				ASSIMP_LOG_WARN("IRR: Failed to match imported materials "
+								"with the materials found in the IRR scene file");
+
+				break;
+			}
+			for (unsigned int i = 0; i < localScene->mNumMaterials; ++i) {
+				// Delete the old material, we don't need it anymore
+				delete localScene->mMaterials[i];
+
+				std::pair<aiMaterial *, unsigned int> &src = root->materials[i];
+				localScene->mMaterials[i] = src.first;
+			}
+
+			// NOTE: Each mesh should have exactly one material assigned,
+			// but we do it in a separate loop if this behavior changes
+			// in future.
+			for (unsigned int i = 0; i < localScene->mNumMeshes; ++i) {
+				// Process material flags
+				aiMesh *mesh = localScene->mMeshes[i];
+
+				// If "trans_vertex_alpha" mode is enabled, search all vertex colors
+				// and check whether they have a common alpha value. This is quite
+				// often the case so we can simply extract it to a shared oacity
+				// value.
+				std::pair<aiMaterial *, unsigned int> &src = root->materials[mesh->mMaterialIndex];
+				aiMaterial *mat = (aiMaterial *)src.first;
+
+				if (mesh->HasVertexColors(0) && src.second & AI_IRRMESH_MAT_trans_vertex_alpha) {
+					bool bdo = true;
+					for (unsigned int a = 1; a < mesh->mNumVertices; ++a) {
+
+						if (mesh->mColors[0][a].a != mesh->mColors[0][a - 1].a) {
+							bdo = false;
+							break;
+						}
+					}
+					if (bdo) {
+						ASSIMP_LOG_INFO("IRR: Replacing mesh vertex alpha with common opacity");
+
+						for (unsigned int a = 0; a < mesh->mNumVertices; ++a)
+							mesh->mColors[0][a].a = 1.f;
+
+						mat->AddProperty(&mesh->mColors[0][0].a, 1, AI_MATKEY_OPACITY);
+					}
+				}
+
+				// If we have a second texture coordinate set and a second texture
+				// (either light-map, normal-map, 2layered material) we need to
+				// setup the correct UV index for it. The texture can either
+				// be diffuse (light-map & 2layer) or a normal map (normal & parallax)
+				if (mesh->HasTextureCoords(1)) {
+
+					int idx = 1;
+					if (src.second & (AI_IRRMESH_MAT_solid_2layer | AI_IRRMESH_MAT_lightmap)) {
+						mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(0));
+					} else if (src.second & AI_IRRMESH_MAT_normalmap_solid) {
+						mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0));
+					}
+				}
+			}
+		} break;
+
+		case Node::LIGHT:
+		case Node::CAMERA:
+
+			// We're already finished with lights and cameras
+			break;
+
+		case Node::SPHERE: {
+			// Generate the sphere model. Our input parameter to
+			// the sphere generation algorithm is the number of
+			// subdivisions of each triangle - but here we have
+			// the number of polygons on a specific axis. Just
+			// use some hard-coded limits to approximate this ...
+			unsigned int mul = root->spherePolyCountX * root->spherePolyCountY;
+			if (mul < 100)
+				mul = 2;
+			else if (mul < 300)
+				mul = 3;
+			else
+				mul = 4;
+
+			meshes.push_back(StandardShapes::MakeMesh(mul,
+					&StandardShapes::MakeSphere));
+
+			// Adjust scaling
+			root->scaling *= root->sphereRadius / 2;
+
+			// Copy one output material
+			CopyMaterial(materials, root->materials, defMatIdx, meshes.back());
+
+			// Now adjust this output material - if there is a first texture
+			// set, setup spherical UV mapping around the Y axis.
+			SetupMapping((aiMaterial *)materials.back(), aiTextureMapping_SPHERE);
+		} break;
+
+		case Node::CUBE: {
+			// Generate an unit cube first
+			meshes.push_back(StandardShapes::MakeMesh(
+					&StandardShapes::MakeHexahedron));
+
+			// Adjust scaling
+			root->scaling *= root->sphereRadius;
+
+			// Copy one output material
+			CopyMaterial(materials, root->materials, defMatIdx, meshes.back());
+
+			// Now adjust this output material - if there is a first texture
+			// set, setup cubic UV mapping
+			SetupMapping((aiMaterial *)materials.back(), aiTextureMapping_BOX);
+		} break;
+
+		case Node::SKYBOX: {
+			// A sky-box is defined by six materials
+			if (root->materials.size() < 6) {
+				ASSIMP_LOG_ERROR("IRR: There should be six materials for a skybox");
+				break;
+			}
+
+			// copy those materials and generate 6 meshes for our new sky-box
+			materials.reserve(materials.size() + 6);
+			for (unsigned int i = 0; i < 6; ++i)
+				materials.insert(materials.end(), root->materials[i].first);
+
+			BuildSkybox(meshes, materials);
+
+			// *************************************************************
+			// Skyboxes will require a different code path for rendering,
+			// so there must be a way for the user to add special support
+			// for IRR skyboxes. We add a 'IRR.SkyBox_' prefix to the node.
+			// *************************************************************
+			root->name = "IRR.SkyBox_" + root->name;
+			ASSIMP_LOG_INFO("IRR: Loading skybox, this will "
+							"require special handling to be displayed correctly");
+		} break;
+
+		case Node::TERRAIN: {
+			// to support terrains, we'd need to have a texture decoder
+			ASSIMP_LOG_ERROR("IRR: Unsupported node - TERRAIN");
+		} break;
+		default:
+			// DUMMY
+			break;
+	};
+
+	// Check whether we added a mesh (or more than one ...). In this case
+	// we'll also need to attach it to the node
+	if (oldMeshSize != (unsigned int)meshes.size()) {
+
+		rootOut->mNumMeshes = (unsigned int)meshes.size() - oldMeshSize;
+		rootOut->mMeshes = new unsigned int[rootOut->mNumMeshes];
+
+		for (unsigned int a = 0; a < rootOut->mNumMeshes; ++a) {
+			rootOut->mMeshes[a] = oldMeshSize + a;
+		}
+	}
+
+	// Setup the name of this node
+	rootOut->mName.Set(root->name);
+
+	// Now compute the final local transformation matrix of the
+	// node from the given translation, rotation and scaling values.
+	// (the rotation is given in Euler angles, XYZ order)
+	//std::swap((float&)root->rotation.z,(float&)root->rotation.y);
+	rootOut->mTransformation.FromEulerAnglesXYZ(AI_DEG_TO_RAD(root->rotation));
+
+	// apply scaling
+	aiMatrix4x4 &mat = rootOut->mTransformation;
+	mat.a1 *= root->scaling.x;
+	mat.b1 *= root->scaling.x;
+	mat.c1 *= root->scaling.x;
+	mat.a2 *= root->scaling.y;
+	mat.b2 *= root->scaling.y;
+	mat.c2 *= root->scaling.y;
+	mat.a3 *= root->scaling.z;
+	mat.b3 *= root->scaling.z;
+	mat.c3 *= root->scaling.z;
+
+	// apply translation
+	mat.a4 += root->position.x;
+	mat.b4 += root->position.y;
+	mat.c4 += root->position.z;
+
+	// now compute animations for the node
+	ComputeAnimations(root, rootOut, anims);
+
+	// Add all children recursively. First allocate enough storage
+	// for them, then call us again
+	rootOut->mNumChildren = (unsigned int)root->children.size();
+	if (rootOut->mNumChildren) {
+
+		rootOut->mChildren = new aiNode *[rootOut->mNumChildren];
+		for (unsigned int i = 0; i < rootOut->mNumChildren; ++i) {
+
+			aiNode *node = rootOut->mChildren[i] = new aiNode();
+			node->mParent = rootOut;
+			GenerateGraph(root->children[i], node, scene, batch, meshes,
+					anims, attach, materials, defMatIdx);
+		}
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void IRRImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+	std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+
+	// Check whether we can read from the file
+	if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open IRR file ", pFile);
+	}
+
+	// Construct the irrXML parser
+	XmlParser st;
+    if (!st.parse( file.get() )) {
+        throw DeadlyImportError("XML parse error while loading IRR file ", pFile);
+    }
+    pugi::xml_node rootElement = st.getRootNode();
+
+	// The root node of the scene
+	Node *root = new Node(Node::DUMMY);
+	root->parent = nullptr;
+	root->name = "<IRRSceneRoot>";
+
+	// Current node parent
+	Node *curParent = root;
+
+	// Scene-graph node we're currently working on
+	Node *curNode = nullptr;
+
+	// List of output cameras
+	std::vector<aiCamera *> cameras;
+
+	// List of output lights
+	std::vector<aiLight *> lights;
+
+	// Batch loader used to load external models
+	BatchLoader batch(pIOHandler);
+	//  batch.SetBasePath(pFile);
+
+	cameras.reserve(5);
+	lights.reserve(5);
+
+	bool inMaterials = false, inAnimator = false;
+	unsigned int guessedAnimCnt = 0, guessedMeshCnt = 0, guessedMatCnt = 0;
+
+	// Parse the XML file
+
+	//while (reader->read())  {
+	for (pugi::xml_node child : rootElement.children())
+		switch (child.type()) {
+			case pugi::node_element:
+				if (!ASSIMP_stricmp(child.name(), "node")) {
+					// ***********************************************************************
+					/*  What we're going to do with the node depends
+                     *  on its type:
+                     *
+                     *  "mesh" - Load a mesh from an external file
+                     *  "cube" - Generate a cube
+                     *  "skybox" - Generate a skybox
+                     *  "light" - A light source
+                     *  "sphere" - Generate a sphere mesh
+                     *  "animatedMesh" - Load an animated mesh from an external file
+                     *    and join its animation channels with ours.
+                     *  "empty" - A dummy node
+                     *  "camera" - A camera
+                     *  "terrain" - a terrain node (data comes from a heightmap)
+                     *  "billboard", ""
+                     *
+                     *  Each of these nodes can be animated and all can have multiple
+                     *  materials assigned (except lights, cameras and dummies, of course).
+                     */
+					// ***********************************************************************
+					//const char *sz = reader->getAttributeValueSafe("type");
+					pugi::xml_attribute attrib = child.attribute("type");
+					Node *nd;
+					if (!ASSIMP_stricmp(attrib.name(), "mesh") || !ASSIMP_stricmp(attrib.name(), "octTree")) {
+						// OctTree's and meshes are treated equally
+						nd = new Node(Node::MESH);
+					} else if (!ASSIMP_stricmp(attrib.name(), "cube")) {
+						nd = new Node(Node::CUBE);
+						++guessedMeshCnt;
+					} else if (!ASSIMP_stricmp(attrib.name(), "skybox")) {
+						nd = new Node(Node::SKYBOX);
+						guessedMeshCnt += 6;
+					} else if (!ASSIMP_stricmp(attrib.name(), "camera")) {
+						nd = new Node(Node::CAMERA);
+
+						// Setup a temporary name for the camera
+						aiCamera *cam = new aiCamera();
+						cam->mName.Set(nd->name);
+						cameras.push_back(cam);
+					} else if (!ASSIMP_stricmp(attrib.name(), "light")) {
+						nd = new Node(Node::LIGHT);
+
+						// Setup a temporary name for the light
+						aiLight *cam = new aiLight();
+						cam->mName.Set(nd->name);
+						lights.push_back(cam);
+					} else if (!ASSIMP_stricmp(attrib.name(), "sphere")) {
+						nd = new Node(Node::SPHERE);
+						++guessedMeshCnt;
+					} else if (!ASSIMP_stricmp(attrib.name(), "animatedMesh")) {
+						nd = new Node(Node::ANIMMESH);
+					} else if (!ASSIMP_stricmp(attrib.name(), "empty")) {
+						nd = new Node(Node::DUMMY);
+					} else if (!ASSIMP_stricmp(attrib.name(), "terrain")) {
+						nd = new Node(Node::TERRAIN);
+					} else if (!ASSIMP_stricmp(attrib.name(), "billBoard")) {
+						// We don't support billboards, so ignore them
+						ASSIMP_LOG_ERROR("IRR: Billboards are not supported by Assimp");
+						nd = new Node(Node::DUMMY);
+					} else {
+						ASSIMP_LOG_WARN("IRR: Found unknown node: ", attrib.name());
+
+						/*  We skip the contents of nodes we don't know.
+                         *  We parse the transformation and all animators
+                         *  and skip the rest.
+                         */
+						nd = new Node(Node::DUMMY);
+					}
+
+					/* Attach the newly created node to the scene-graph
+                     */
+					curNode = nd;
+					nd->parent = curParent;
+					curParent->children.push_back(nd);
+				} else if (!ASSIMP_stricmp(child.name(), "materials")) {
+					inMaterials = true;
+				} else if (!ASSIMP_stricmp(child.name(), "animators")) {
+					inAnimator = true;
+				} else if (!ASSIMP_stricmp(child.name(), "attributes")) {
+					//  We should have a valid node here
+					//  FIX: no ... the scene root node is also contained in an attributes block
+					if (!curNode) {
+						continue;
+					}
+
+					Animator *curAnim = nullptr;
+
+					// Materials can occur for nearly any type of node
+					if (inMaterials && curNode->type != Node::DUMMY) {
+						//  This is a material description - parse it!
+						curNode->materials.push_back(std::pair<aiMaterial *, unsigned int>());
+						std::pair<aiMaterial *, unsigned int> &p = curNode->materials.back();
+
+						p.first = ParseMaterial(p.second);
+						++guessedMatCnt;
+						continue;
+					} else if (inAnimator) {
+						//  This is an animation path - add a new animator
+						//  to the list.
+						curNode->animators.push_back(Animator());
+						curAnim = &curNode->animators.back();
+
+						++guessedAnimCnt;
+					}
+
+					/*  Parse all elements in the attributes block
+                     *  and process them.
+                     */
+					//					while (reader->read()) {
+					for (pugi::xml_node attrib : child.children()) {
+						if (attrib.type() == pugi::node_element) {
+							//if (reader->getNodeType() == EXN_ELEMENT) {
+							//if (!ASSIMP_stricmp(reader->getNodeName(), "vector3d")) {
+							if (!ASSIMP_stricmp(attrib.name(), "vector3d")) {
+								VectorProperty prop;
+								ReadVectorProperty(prop);
+
+								if (inAnimator) {
+									if (curAnim->type == Animator::ROTATION && prop.name == "Rotation") {
+										// We store the rotation euler angles in 'direction'
+										curAnim->direction = prop.value;
+									} else if (curAnim->type == Animator::FOLLOW_SPLINE) {
+										// Check whether the vector follows the PointN naming scheme,
+										// here N is the ONE-based index of the point
+										if (prop.name.length() >= 6 && prop.name.substr(0, 5) == "Point") {
+											// Add a new key to the list
+											curAnim->splineKeys.push_back(aiVectorKey());
+											aiVectorKey &key = curAnim->splineKeys.back();
+
+											// and parse its properties
+											key.mValue = prop.value;
+											key.mTime = strtoul10(&prop.name[5]);
+										}
+									} else if (curAnim->type == Animator::FLY_CIRCLE) {
+										if (prop.name == "Center") {
+											curAnim->circleCenter = prop.value;
+										} else if (prop.name == "Direction") {
+											curAnim->direction = prop.value;
+
+											// From Irrlicht's source - a workaround for backward compatibility with Irrlicht 1.1
+											if (curAnim->direction == aiVector3D()) {
+												curAnim->direction = aiVector3D(0.f, 1.f, 0.f);
+											} else
+												curAnim->direction.Normalize();
+										}
+									} else if (curAnim->type == Animator::FLY_STRAIGHT) {
+										if (prop.name == "Start") {
+											// We reuse the field here
+											curAnim->circleCenter = prop.value;
+										} else if (prop.name == "End") {
+											// We reuse the field here
+											curAnim->direction = prop.value;
+										}
+									}
+								} else {
+									if (prop.name == "Position") {
+										curNode->position = prop.value;
+									} else if (prop.name == "Rotation") {
+										curNode->rotation = prop.value;
+									} else if (prop.name == "Scale") {
+										curNode->scaling = prop.value;
+									} else if (Node::CAMERA == curNode->type) {
+										aiCamera *cam = cameras.back();
+										if (prop.name == "Target") {
+											cam->mLookAt = prop.value;
+										} else if (prop.name == "UpVector") {
+											cam->mUp = prop.value;
+										}
+									}
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "bool")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "bool")) {
+								BoolProperty prop;
+								ReadBoolProperty(prop);
+
+								if (inAnimator && curAnim->type == Animator::FLY_CIRCLE && prop.name == "Loop") {
+									curAnim->loop = prop.value;
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "float")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "float")) {
+								FloatProperty prop;
+								ReadFloatProperty(prop);
+
+								if (inAnimator) {
+									// The speed property exists for several animators
+									if (prop.name == "Speed") {
+										curAnim->speed = prop.value;
+									} else if (curAnim->type == Animator::FLY_CIRCLE && prop.name == "Radius") {
+										curAnim->circleRadius = prop.value;
+									} else if (curAnim->type == Animator::FOLLOW_SPLINE && prop.name == "Tightness") {
+										curAnim->tightness = prop.value;
+									}
+								} else {
+									if (prop.name == "FramesPerSecond" && Node::ANIMMESH == curNode->type) {
+										curNode->framesPerSecond = prop.value;
+									} else if (Node::CAMERA == curNode->type) {
+										/*  This is the vertical, not the horizontal FOV.
+                                    *  We need to compute the right FOV from the
+                                    *  screen aspect which we don't know yet.
+                                    */
+										if (prop.name == "Fovy") {
+											cameras.back()->mHorizontalFOV = prop.value;
+										} else if (prop.name == "Aspect") {
+											cameras.back()->mAspect = prop.value;
+										} else if (prop.name == "ZNear") {
+											cameras.back()->mClipPlaneNear = prop.value;
+										} else if (prop.name == "ZFar") {
+											cameras.back()->mClipPlaneFar = prop.value;
+										}
+									} else if (Node::LIGHT == curNode->type) {
+										/*  Additional light information
+                                     */
+										if (prop.name == "Attenuation") {
+											lights.back()->mAttenuationLinear = prop.value;
+										} else if (prop.name == "OuterCone") {
+											lights.back()->mAngleOuterCone = AI_DEG_TO_RAD(prop.value);
+										} else if (prop.name == "InnerCone") {
+											lights.back()->mAngleInnerCone = AI_DEG_TO_RAD(prop.value);
+										}
+									}
+									// radius of the sphere to be generated -
+									// or alternatively, size of the cube
+									else if ((Node::SPHERE == curNode->type && prop.name == "Radius") || (Node::CUBE == curNode->type && prop.name == "Size")) {
+
+										curNode->sphereRadius = prop.value;
+									}
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "int")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "int")) {
+								IntProperty prop;
+								ReadIntProperty(prop);
+
+								if (inAnimator) {
+									if (curAnim->type == Animator::FLY_STRAIGHT && prop.name == "TimeForWay") {
+										curAnim->timeForWay = prop.value;
+									}
+								} else {
+									// sphere polygon numbers in each direction
+									if (Node::SPHERE == curNode->type) {
+
+										if (prop.name == "PolyCountX") {
+											curNode->spherePolyCountX = prop.value;
+										} else if (prop.name == "PolyCountY") {
+											curNode->spherePolyCountY = prop.value;
+										}
+									}
+								}
+								//} else if (!ASSIMP_stricmp(reader->getNodeName(), "string") || !ASSIMP_stricmp(reader->getNodeName(), "enum")) {
+							} else if (!ASSIMP_stricmp(attrib.name(), "string") || !ASSIMP_stricmp(attrib.name(), "enum")) {
+								StringProperty prop;
+								ReadStringProperty(prop);
+								if (prop.value.length()) {
+									if (prop.name == "Name") {
+										curNode->name = prop.value;
+
+										/*  If we're either a camera or a light source
+                                     *  we need to update the name in the aiLight/
+                                     *  aiCamera structure, too.
+                                     */
+										if (Node::CAMERA == curNode->type) {
+											cameras.back()->mName.Set(prop.value);
+										} else if (Node::LIGHT == curNode->type) {
+											lights.back()->mName.Set(prop.value);
+										}
+									} else if (Node::LIGHT == curNode->type && "LightType" == prop.name) {
+										if (prop.value == "Spot")
+											lights.back()->mType = aiLightSource_SPOT;
+										else if (prop.value == "Point")
+											lights.back()->mType = aiLightSource_POINT;
+										else if (prop.value == "Directional")
+											lights.back()->mType = aiLightSource_DIRECTIONAL;
+										else {
+											// We won't pass the validation with aiLightSourceType_UNDEFINED,
+											// so we remove the light and replace it with a silly dummy node
+											delete lights.back();
+											lights.pop_back();
+											curNode->type = Node::DUMMY;
+
+											ASSIMP_LOG_ERROR("Ignoring light of unknown type: ", prop.value);
+										}
+									} else if ((prop.name == "Mesh" && Node::MESH == curNode->type) ||
+											   Node::ANIMMESH == curNode->type) {
+    								/*  This is the file name of the mesh - either
+                                     *  animated or not. We need to make sure we setup
+                                     *  the correct post-processing settings here.
+                                     */
+										unsigned int pp = 0;
+										BatchLoader::PropertyMap map;
+
+										/* If the mesh is a static one remove all animations from the impor data
+                                     */
+										if (Node::ANIMMESH != curNode->type) {
+											pp |= aiProcess_RemoveComponent;
+											SetGenericProperty<int>(map.ints, AI_CONFIG_PP_RVC_FLAGS,
+													aiComponent_ANIMATIONS | aiComponent_BONEWEIGHTS);
+										}
+
+										/*  TODO: maybe implement the protection against recursive
+                                        *  loading calls directly in BatchLoader? The current
+                                        *  implementation is not absolutely safe. A LWS and an IRR
+                                        *  file referencing each other *could* cause the system to
+                                        *  recurse forever.
+                                        */
+
+										const std::string extension = GetExtension(prop.value);
+										if ("irr" == extension) {
+											ASSIMP_LOG_ERROR("IRR: Can't load another IRR file recursively");
+										} else {
+											curNode->id = batch.AddLoadRequest(prop.value, pp, &map);
+											curNode->meshPath = prop.value;
+										}
+									} else if (inAnimator && prop.name == "Type") {
+										// type of the animator
+										if (prop.value == "rotation") {
+											curAnim->type = Animator::ROTATION;
+										} else if (prop.value == "flyCircle") {
+											curAnim->type = Animator::FLY_CIRCLE;
+										} else if (prop.value == "flyStraight") {
+											curAnim->type = Animator::FLY_CIRCLE;
+										} else if (prop.value == "followSpline") {
+											curAnim->type = Animator::FOLLOW_SPLINE;
+										} else {
+											ASSIMP_LOG_WARN("IRR: Ignoring unknown animator: ", prop.value);
+
+											curAnim->type = Animator::UNKNOWN;
+										}
+									}
+								}
+							}
+							//} else if (reader->getNodeType() == EXN_ELEMENT_END && !ASSIMP_stricmp(reader->getNodeName(), "attributes")) {
+						} else if (attrib.type() == pugi::node_null && !ASSIMP_stricmp(attrib.name(), "attributes")) {
+							break;
+						}
+					}
+				}
+				break;
+
+				/*case EXN_ELEMENT_END:
+
+				// If we reached the end of a node, we need to continue processing its parent
+				if (!ASSIMP_stricmp(reader->getNodeName(), "node")) {
+					if (!curNode) {
+						// currently is no node set. We need to go
+						// back in the node hierarchy
+						if (!curParent) {
+							curParent = root;
+							ASSIMP_LOG_ERROR("IRR: Too many closing <node> elements");
+						} else
+							curParent = curParent->parent;
+					} else
+						curNode = nullptr;
+				}
+				// clear all flags
+				else if (!ASSIMP_stricmp(reader->getNodeName(), "materials")) {
+					inMaterials = false;
+				} else if (!ASSIMP_stricmp(reader->getNodeName(), "animators")) {
+					inAnimator = false;
+				}
+				break;*/
+
+			default:
+				// GCC complains that not all enumeration values are handled
+				break;
+		}
+	//}
+
+	//  Now iterate through all cameras and compute their final (horizontal) FOV
+	for (aiCamera *cam : cameras) {
+		// screen aspect could be missing
+		if (cam->mAspect) {
+			cam->mHorizontalFOV *= cam->mAspect;
+		} else {
+			ASSIMP_LOG_WARN("IRR: Camera aspect is not given, can't compute horizontal FOV");
+		}
+	}
+
+	batch.LoadAll();
+
+	// Allocate a temporary scene data structure
+	aiScene *tempScene = new aiScene();
+	tempScene->mRootNode = new aiNode();
+	tempScene->mRootNode->mName.Set("<IRRRoot>");
+
+	// Copy the cameras to the output array
+	if (!cameras.empty()) {
+		tempScene->mNumCameras = (unsigned int)cameras.size();
+		tempScene->mCameras = new aiCamera *[tempScene->mNumCameras];
+		::memcpy(tempScene->mCameras, &cameras[0], sizeof(void *) * tempScene->mNumCameras);
+	}
+
+	// Copy the light sources to the output array
+	if (!lights.empty()) {
+		tempScene->mNumLights = (unsigned int)lights.size();
+		tempScene->mLights = new aiLight *[tempScene->mNumLights];
+		::memcpy(tempScene->mLights, &lights[0], sizeof(void *) * tempScene->mNumLights);
+	}
+
+	// temporary data
+	std::vector<aiNodeAnim *> anims;
+	std::vector<aiMaterial *> materials;
+	std::vector<AttachmentInfo> attach;
+	std::vector<aiMesh *> meshes;
+
+	// try to guess how much storage we'll need
+	anims.reserve(guessedAnimCnt + (guessedAnimCnt >> 2));
+	meshes.reserve(guessedMeshCnt + (guessedMeshCnt >> 2));
+	materials.reserve(guessedMatCnt + (guessedMatCnt >> 2));
+
+	// Now process our scene-graph recursively: generate final
+	// meshes and generate animation channels for all nodes.
+	unsigned int defMatIdx = UINT_MAX;
+	GenerateGraph(root, tempScene->mRootNode, tempScene,
+			batch, meshes, anims, attach, materials, defMatIdx);
+
+	if (!anims.empty()) {
+		tempScene->mNumAnimations = 1;
+		tempScene->mAnimations = new aiAnimation *[tempScene->mNumAnimations];
+		aiAnimation *an = tempScene->mAnimations[0] = new aiAnimation();
+
+		// ***********************************************************
+		// This is only the global animation channel of the scene.
+		// If there are animated models, they will have separate
+		// animation channels in the scene. To display IRR scenes
+		// correctly, users will need to combine the global anim
+		// channel with all the local animations they want to play
+		// ***********************************************************
+		an->mName.Set("Irr_GlobalAnimChannel");
+
+		// copy all node animation channels to the global channel
+		an->mNumChannels = (unsigned int)anims.size();
+		an->mChannels = new aiNodeAnim *[an->mNumChannels];
+		::memcpy(an->mChannels, &anims[0], sizeof(void *) * an->mNumChannels);
+	}
+	if (!meshes.empty()) {
+		// copy all meshes to the temporary scene
+		tempScene->mNumMeshes = (unsigned int)meshes.size();
+		tempScene->mMeshes = new aiMesh *[tempScene->mNumMeshes];
+		::memcpy(tempScene->mMeshes, &meshes[0], tempScene->mNumMeshes * sizeof(void *));
+	}
+
+	// Copy all materials to the output array
+	if (!materials.empty()) {
+		tempScene->mNumMaterials = (unsigned int)materials.size();
+		tempScene->mMaterials = new aiMaterial *[tempScene->mNumMaterials];
+		::memcpy(tempScene->mMaterials, &materials[0], sizeof(void *) * tempScene->mNumMaterials);
+	}
+
+	//  Now merge all sub scenes and attach them to the correct
+	//  attachment points in the scenegraph.
+	SceneCombiner::MergeScenes(&pScene, tempScene, attach,
+			AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES | (!configSpeedFlag ? (
+																			  AI_INT_MERGE_SCENE_GEN_UNIQUE_NAMES_IF_NECESSARY | AI_INT_MERGE_SCENE_GEN_UNIQUE_MATNAMES) :
+																	  0));
+
+	// If we have no meshes | no materials now set the INCOMPLETE
+	// scene flag. This is necessary if we failed to load all
+	// models from external files
+	if (!pScene->mNumMeshes || !pScene->mNumMaterials) {
+		ASSIMP_LOG_WARN("IRR: No meshes loaded, setting AI_SCENE_FLAGS_INCOMPLETE");
+		pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
+	}
+
+	// Finished ... everything destructs automatically and all
+	// temporary scenes have already been deleted by MergeScenes()
+	delete root;
+}
+
+#endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER
diff --git a/libs/assimp/code/AssetLib/Irr/IRRLoader.h b/libs/assimp/code/AssetLib/Irr/IRRLoader.h
new file mode 100644
index 0000000..d56c4ca
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Irr/IRRLoader.h
@@ -0,0 +1,284 @@
+/*
+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 IRRLoader.h
+ *  @brief Declaration of the .irrMesh (Irrlight Engine Mesh Format)
+ *  importer class.
+ */
+#ifndef AI_IRRLOADER_H_INCLUDED
+#define AI_IRRLOADER_H_INCLUDED
+
+#include "AssetLib/Irr/IRRShared.h"
+#include "Common/Importer.h"
+
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/anim.h>
+
+namespace Assimp    {
+
+// ---------------------------------------------------------------------------
+/** Irr importer class.
+ *
+ * Irr is the native scene file format of the Irrlight engine and its editor
+ * irrEdit. As IrrEdit itself is capable of importing quite many file formats,
+ * it might be a good file format for data exchange.
+ */
+class IRRImporter : public BaseImporter, public IrrlichtBase {
+public:
+    IRRImporter();
+    ~IRRImporter() override;
+
+    // -------------------------------------------------------------------
+    /** Returns whether the class can handle the format of the given file.
+     *  See BaseImporter::CanRead() for details.
+     */
+    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
+        bool checkSig) const override;
+
+protected:
+    const aiImporterDesc* GetInfo () const override;
+    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) override;
+    void SetupProperties(const Importer* pImp) override;
+
+private:
+    /** Data structure for a scene-graph node animator
+     */
+    struct Animator {
+        // Type of the animator
+        enum AT {
+            UNKNOWN       = 0x0,
+            ROTATION      = 0x1,
+            FLY_CIRCLE    = 0x2,
+            FLY_STRAIGHT  = 0x3,
+            FOLLOW_SPLINE = 0x4,
+            OTHER         = 0x5
+
+        } type;
+
+        explicit Animator(AT t = UNKNOWN)
+            : type              (t)
+            , speed             ( ai_real( 0.001 ) )
+            , direction         ( ai_real( 0.0 ), ai_real( 1.0 ), ai_real( 0.0 ) )
+            , circleRadius      ( ai_real( 1.0) )
+            , tightness         ( ai_real( 0.5 ) )
+            , loop              (true)
+            , timeForWay        (100)
+        {
+        }
+
+
+        // common parameters
+        ai_real speed;
+        aiVector3D direction;
+
+        // FLY_CIRCLE
+        aiVector3D circleCenter;
+        ai_real circleRadius;
+
+        // FOLLOW_SPLINE
+        ai_real tightness;
+        std::vector<aiVectorKey> splineKeys;
+
+        // ROTATION (angles given in direction)
+
+        // FLY STRAIGHT
+        // circleCenter = start, direction = end
+        bool loop;
+        int timeForWay;
+    };
+
+    /** Data structure for a scene-graph node in an IRR file
+     */
+    struct Node
+    {
+        // Type of the node
+        enum ET
+        {
+            LIGHT,
+            CUBE,
+            MESH,
+            SKYBOX,
+            DUMMY,
+            CAMERA,
+            TERRAIN,
+            SPHERE,
+            ANIMMESH
+        } type;
+
+        explicit Node(ET t)
+            :   type                (t)
+            ,   scaling             (1.0,1.0,1.0) // assume uniform scaling by default
+            ,   parent()
+            ,   framesPerSecond     (0.0)
+            ,   id()
+            ,   sphereRadius        (1.0)
+            ,   spherePolyCountX    (100)
+            ,   spherePolyCountY    (100)
+        {
+
+            // Generate a default name for the node
+            char buffer[128];
+            static int cnt;
+            ai_snprintf(buffer, 128, "IrrNode_%i",cnt++);
+            name = std::string(buffer);
+
+            // reserve space for up to 5 materials
+            materials.reserve(5);
+
+            // reserve space for up to 5 children
+            children.reserve(5);
+        }
+
+        // Transformation of the node
+        aiVector3D position, rotation, scaling;
+
+        // Name of the node
+        std::string name;
+
+        // List of all child nodes
+        std::vector<Node*> children;
+
+        // Parent node
+        Node* parent;
+
+        // Animated meshes: frames per second
+        // 0.f if not specified
+        ai_real framesPerSecond;
+
+        // Meshes: path to the mesh to be loaded
+        std::string meshPath;
+        unsigned int id;
+
+        // Meshes: List of materials to be assigned
+        // along with their corresponding material flags
+        std::vector< std::pair<aiMaterial*, unsigned int> > materials;
+
+        // Spheres: radius of the sphere to be generates
+        ai_real sphereRadius;
+
+        // Spheres: Number of polygons in the x,y direction
+        unsigned int spherePolyCountX,spherePolyCountY;
+
+        // List of all animators assigned to the node
+        std::list<Animator> animators;
+    };
+
+    /** Data structure for a vertex in an IRR skybox
+     */
+    struct SkyboxVertex
+    {
+        SkyboxVertex()
+        {}
+
+        //! Construction from single vertex components
+        SkyboxVertex(ai_real px, ai_real py, ai_real pz,
+            ai_real nx, ai_real ny, ai_real nz,
+            ai_real uvx, ai_real uvy)
+
+            :   position    (px,py,pz)
+            ,   normal      (nx,ny,nz)
+            ,   uv          (uvx,uvy,0.0)
+        {}
+
+        aiVector3D position, normal, uv;
+    };
+
+
+    // -------------------------------------------------------------------
+    /// Fill the scene-graph recursively
+    void GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
+        BatchLoader& batch,
+        std::vector<aiMesh*>& meshes,
+        std::vector<aiNodeAnim*>& anims,
+        std::vector<AttachmentInfo>& attach,
+        std::vector<aiMaterial*>& materials,
+        unsigned int& defaultMatIdx);
+
+    // -------------------------------------------------------------------
+    /// Generate a mesh that consists of just a single quad
+    aiMesh* BuildSingleQuadMesh(const SkyboxVertex& v1,
+        const SkyboxVertex& v2,
+        const SkyboxVertex& v3,
+        const SkyboxVertex& v4);
+
+    // -------------------------------------------------------------------
+    /// Build a sky-box
+    ///
+    /// @param meshes Receives 6 output meshes
+    /// @param materials The last 6 materials are assigned to the newly
+    ///                  created meshes. The names of the materials are adjusted.
+    void BuildSkybox(std::vector<aiMesh*>& meshes,
+        std::vector<aiMaterial*> materials);
+
+    // -------------------------------------------------------------------
+    /** Copy a material for a mesh to the output material list
+     *
+     *  @param materials Receives an output material
+     *  @param inmaterials List of input materials
+     *  @param defMatIdx Default material index - UINT_MAX if not present
+     *  @param mesh Mesh to work on
+     */
+    void CopyMaterial(std::vector<aiMaterial*>&  materials,
+        std::vector< std::pair<aiMaterial*, unsigned int> >& inmaterials,
+        unsigned int& defMatIdx,
+        aiMesh* mesh);
+
+    // -------------------------------------------------------------------
+    /** Compute animations for a specific node
+     *
+     *  @param root Node to be processed
+     *  @param anims The list of output animations
+     */
+    void ComputeAnimations(Node* root, aiNode* real,
+        std::vector<aiNodeAnim*>& anims);
+
+private:
+    /// Configuration option: desired output FPS
+    double fps;
+
+    /// Configuration option: speed flag was set?
+    bool configSpeedFlag;
+};
+
+} // end of namespace Assimp
+
+#endif // AI_IRRIMPORTER_H_INC
diff --git a/libs/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp b/libs/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp
new file mode 100644
index 0000000..90b4d85
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Irr/IRRMeshLoader.cpp
@@ -0,0 +1,502 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2022, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+/** @file Implementation of the IrrMesh importer class */
+
+#ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
+
+#include "IRRMeshLoader.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/material.h>
+#include <assimp/mesh.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <memory>
+
+using namespace Assimp;
+
+static const aiImporterDesc desc = {
+	"Irrlicht Mesh Reader",
+	"",
+	"",
+	"http://irrlicht.sourceforge.net/",
+	aiImporterFlags_SupportTextFlavour,
+	0,
+	0,
+	0,
+	0,
+	"xml irrmesh"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+IRRMeshImporter::IRRMeshImporter() :
+        BaseImporter(),
+        IrrlichtBase() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+IRRMeshImporter::~IRRMeshImporter() {}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool IRRMeshImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool /*checkSig*/) const {
+	/* NOTE: A simple check for the file extension is not enough
+	 * here. Irrmesh and irr are easy, but xml is too generic
+	 * and could be collada, too. So we need to open the file and
+	 * search for typical tokens.
+	 */
+	static const char *tokens[] = { "irrmesh" };
+	return SearchFileHeaderForToken(pIOHandler, pFile, tokens, AI_COUNT_OF(tokens));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Get a list of all file extensions which are handled by this class
+const aiImporterDesc *IRRMeshImporter::GetInfo() const {
+	return &desc;
+}
+
+static void releaseMaterial(aiMaterial **mat) {
+	if (*mat != nullptr) {
+		delete *mat;
+		*mat = nullptr;
+	}
+}
+
+static void releaseMesh(aiMesh **mesh) {
+	if (*mesh != nullptr) {
+		delete *mesh;
+		*mesh = nullptr;
+	}
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void IRRMeshImporter::InternReadFile(const std::string &pFile,
+		aiScene *pScene, IOSystem *pIOHandler) {
+	std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+
+	// Check whether we can read from the file
+	if (file.get() == NULL)
+        throw DeadlyImportError("Failed to open IRRMESH file ", pFile);
+
+	// Construct the irrXML parser
+	XmlParser parser;
+    if (!parser.parse( file.get() )) {
+        throw DeadlyImportError("XML parse error while loading IRRMESH file ", pFile);
+    }
+    XmlNode root = parser.getRootNode();
+
+	// final data
+	std::vector<aiMaterial *> materials;
+	std::vector<aiMesh *> meshes;
+	materials.reserve(5);
+	meshes.reserve(5);
+
+	// temporary data - current mesh buffer
+	aiMaterial *curMat = nullptr;
+	aiMesh *curMesh = nullptr;
+	unsigned int curMatFlags = 0;
+
+	std::vector<aiVector3D> curVertices, curNormals, curTangents, curBitangents;
+	std::vector<aiColor4D> curColors;
+	std::vector<aiVector3D> curUVs, curUV2s;
+
+	// some temporary variables
+	int textMeaning = 0;
+	int vertexFormat = 0; // 0 = normal; 1 = 2 tcoords, 2 = tangents
+	bool useColors = false;
+
+	// Parse the XML file
+	for (pugi::xml_node child : root.children()) {
+		if (child.type() == pugi::node_element) {
+			if (!ASSIMP_stricmp(child.name(), "buffer") && (curMat || curMesh)) {
+				// end of previous buffer. A material and a mesh should be there
+				if (!curMat || !curMesh) {
+					ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
+					releaseMaterial(&curMat);
+					releaseMesh(&curMesh);
+				} else {
+					materials.push_back(curMat);
+					meshes.push_back(curMesh);
+				}
+				curMat = nullptr;
+				curMesh = nullptr;
+
+				curVertices.clear();
+				curColors.clear();
+				curNormals.clear();
+				curUV2s.clear();
+				curUVs.clear();
+				curTangents.clear();
+				curBitangents.clear();
+			}
+
+			if (!ASSIMP_stricmp(child.name(), "material")) {
+				if (curMat) {
+					ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");
+					releaseMaterial(&curMat);
+				}
+				curMat = ParseMaterial(curMatFlags);
+			}
+			/* no else here! */ if (!ASSIMP_stricmp(child.name(), "vertices")) {
+				pugi::xml_attribute attr = child.attribute("vertexCount");
+				int num = attr.as_int();
+                //int num = reader->getAttributeValueAsInt("vertexCount");
+
+				if (!num) {
+					// This is possible ... remove the mesh from the list and skip further reading
+					ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices");
+
+					releaseMaterial(&curMat);
+					releaseMesh(&curMesh);
+					textMeaning = 0;
+					continue;
+				}
+
+				curVertices.reserve(num);
+				curNormals.reserve(num);
+				curColors.reserve(num);
+				curUVs.reserve(num);
+
+				// Determine the file format
+				//const char *t = reader->getAttributeValueSafe("type");
+                pugi::xml_attribute t = child.attribute("type");
+				if (!ASSIMP_stricmp("2tcoords", t.name())) {
+					curUV2s.reserve(num);
+					vertexFormat = 1;
+
+					if (curMatFlags & AI_IRRMESH_EXTRA_2ND_TEXTURE) {
+						// *********************************************************
+						// We have a second texture! So use this UV channel
+						// for it. The 2nd texture can be either a normal
+						// texture (solid_2layer or lightmap_xxx) or a normal
+						// map (normal_..., parallax_...)
+						// *********************************************************
+						int idx = 1;
+						aiMaterial *mat = (aiMaterial *)curMat;
+
+						if (curMatFlags & AI_IRRMESH_MAT_lightmap) {
+							mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_LIGHTMAP(0));
+						} else if (curMatFlags & AI_IRRMESH_MAT_normalmap_solid) {
+							mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_NORMALS(0));
+						} else if (curMatFlags & AI_IRRMESH_MAT_solid_2layer) {
+							mat->AddProperty(&idx, 1, AI_MATKEY_UVWSRC_DIFFUSE(1));
+						}
+					}
+				} else if (!ASSIMP_stricmp("tangents", t.name())) {
+					curTangents.reserve(num);
+					curBitangents.reserve(num);
+					vertexFormat = 2;
+				} else if (ASSIMP_stricmp("standard", t.name())) {
+					releaseMaterial(&curMat);
+					ASSIMP_LOG_WARN("IRRMESH: Unknown vertex format");
+				} else
+					vertexFormat = 0;
+				textMeaning = 1;
+			} else if (!ASSIMP_stricmp(child.name(), "indices")) {
+				if (curVertices.empty() && curMat) {
+					releaseMaterial(&curMat);
+					throw DeadlyImportError("IRRMESH: indices must come after vertices");
+				}
+
+				textMeaning = 2;
+
+				// start a new mesh
+				curMesh = new aiMesh();
+
+				// allocate storage for all faces
+				pugi::xml_attribute attr = child.attribute("indexCount");
+				curMesh->mNumVertices = attr.as_int();
+				if (!curMesh->mNumVertices) {
+					// This is possible ... remove the mesh from the list and skip further reading
+					ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices");
+
+					// mesh - away
+					releaseMesh(&curMesh);
+
+					// material - away
+					releaseMaterial(&curMat);
+
+					textMeaning = 0;
+					continue;
+				}
+
+				if (curMesh->mNumVertices % 3) {
+					ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3");
+				}
+
+				curMesh->mNumFaces = curMesh->mNumVertices / 3;
+				curMesh->mFaces = new aiFace[curMesh->mNumFaces];
+
+				// setup some members
+				curMesh->mMaterialIndex = (unsigned int)materials.size();
+				curMesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+				// allocate storage for all vertices
+				curMesh->mVertices = new aiVector3D[curMesh->mNumVertices];
+
+				if (curNormals.size() == curVertices.size()) {
+					curMesh->mNormals = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curTangents.size() == curVertices.size()) {
+					curMesh->mTangents = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curBitangents.size() == curVertices.size()) {
+					curMesh->mBitangents = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curColors.size() == curVertices.size() && useColors) {
+					curMesh->mColors[0] = new aiColor4D[curMesh->mNumVertices];
+				}
+				if (curUVs.size() == curVertices.size()) {
+					curMesh->mTextureCoords[0] = new aiVector3D[curMesh->mNumVertices];
+				}
+				if (curUV2s.size() == curVertices.size()) {
+					curMesh->mTextureCoords[1] = new aiVector3D[curMesh->mNumVertices];
+				}
+			}
+			//break;
+
+			//case EXN_TEXT: {
+			const char *sz = child.child_value();
+			if (textMeaning == 1) {
+				textMeaning = 0;
+
+				// read vertices
+				do {
+					SkipSpacesAndLineEnd(&sz);
+					aiVector3D temp;
+					aiColor4D c;
+
+					// Read the vertex position
+					sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+					SkipSpaces(&sz);
+					curVertices.push_back(temp);
+
+					// Read the vertex normals
+					sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+					SkipSpaces(&sz);
+					curNormals.push_back(temp);
+
+					// read the vertex colors
+					uint32_t clr = strtoul16(sz, &sz);
+					ColorFromARGBPacked(clr, c);
+
+					if (!curColors.empty() && c != *(curColors.end() - 1))
+						useColors = true;
+
+					curColors.push_back(c);
+					SkipSpaces(&sz);
+
+					// read the first UV coordinate set
+					sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+					SkipSpaces(&sz);
+
+					sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+					SkipSpaces(&sz);
+					temp.z = 0.f;
+					temp.y = 1.f - temp.y; // DX to OGL
+					curUVs.push_back(temp);
+
+					// read the (optional) second UV coordinate set
+					if (vertexFormat == 1) {
+						sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+						temp.y = 1.f - temp.y; // DX to OGL
+						curUV2s.push_back(temp);
+					}
+					// read optional tangent and bitangent vectors
+					else if (vertexFormat == 2) {
+						// tangents
+						sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+						SkipSpaces(&sz);
+						temp.y *= -1.0f;
+						curTangents.push_back(temp);
+
+						// bitangents
+						sz = fast_atoreal_move<float>(sz, (float &)temp.x);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.z);
+						SkipSpaces(&sz);
+
+						sz = fast_atoreal_move<float>(sz, (float &)temp.y);
+						SkipSpaces(&sz);
+						temp.y *= -1.0f;
+						curBitangents.push_back(temp);
+					}
+				}
+
+				/* IMPORTANT: We assume that each vertex is specified in one
+                line. So we can skip the rest of the line - unknown vertex
+                elements are ignored.
+                */
+
+				while (SkipLine(&sz));
+			} else if (textMeaning == 2) {
+				textMeaning = 0;
+
+				// read indices
+				aiFace *curFace = curMesh->mFaces;
+				aiFace *const faceEnd = curMesh->mFaces + curMesh->mNumFaces;
+
+				aiVector3D *pcV = curMesh->mVertices;
+				aiVector3D *pcN = curMesh->mNormals;
+				aiVector3D *pcT = curMesh->mTangents;
+				aiVector3D *pcB = curMesh->mBitangents;
+				aiColor4D *pcC0 = curMesh->mColors[0];
+				aiVector3D *pcT0 = curMesh->mTextureCoords[0];
+				aiVector3D *pcT1 = curMesh->mTextureCoords[1];
+
+				unsigned int curIdx = 0;
+				unsigned int total = 0;
+				while (SkipSpacesAndLineEnd(&sz)) {
+					if (curFace >= faceEnd) {
+						ASSIMP_LOG_ERROR("IRRMESH: Too many indices");
+						break;
+					}
+					if (!curIdx) {
+						curFace->mNumIndices = 3;
+						curFace->mIndices = new unsigned int[3];
+					}
+
+					unsigned int idx = strtoul10(sz, &sz);
+					if (idx >= curVertices.size()) {
+						ASSIMP_LOG_ERROR("IRRMESH: Index out of range");
+						idx = 0;
+					}
+
+					curFace->mIndices[curIdx] = total++;
+
+					*pcV++ = curVertices[idx];
+					if (pcN) *pcN++ = curNormals[idx];
+					if (pcT) *pcT++ = curTangents[idx];
+					if (pcB) *pcB++ = curBitangents[idx];
+					if (pcC0) *pcC0++ = curColors[idx];
+					if (pcT0) *pcT0++ = curUVs[idx];
+					if (pcT1) *pcT1++ = curUV2s[idx];
+
+					if (++curIdx == 3) {
+						++curFace;
+						curIdx = 0;
+					}
+				}
+
+				if (curFace != faceEnd)
+					ASSIMP_LOG_ERROR("IRRMESH: Not enough indices");
+
+				// Finish processing the mesh - do some small material workarounds
+				if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) {
+					// Take the opacity value of the current material
+					// from the common vertex color alpha
+					aiMaterial *mat = (aiMaterial *)curMat;
+					mat->AddProperty(&curColors[0].a, 1, AI_MATKEY_OPACITY);
+				}
+			}
+		}
+	}
+
+	// End of the last buffer. A material and a mesh should be there
+	if (curMat || curMesh) {
+		if (!curMat || !curMesh) {
+			ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
+			releaseMaterial(&curMat);
+			releaseMesh(&curMesh);
+		} else {
+			materials.push_back(curMat);
+			meshes.push_back(curMesh);
+		}
+	}
+
+	if (materials.empty()) {
+		throw DeadlyImportError("IRRMESH: Unable to read a mesh from this file");
+	}
+
+	// now generate the output scene
+	pScene->mNumMeshes = (unsigned int)meshes.size();
+	pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+		pScene->mMeshes[i] = meshes[i];
+
+		// clean this value ...
+		pScene->mMeshes[i]->mNumUVComponents[3] = 0;
+	}
+
+	pScene->mNumMaterials = (unsigned int)materials.size();
+	pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+	::memcpy(pScene->mMaterials, &materials[0], sizeof(void *) * pScene->mNumMaterials);
+
+	pScene->mRootNode = new aiNode();
+	pScene->mRootNode->mName.Set("<IRRMesh>");
+	pScene->mRootNode->mNumMeshes = pScene->mNumMeshes;
+	pScene->mRootNode->mMeshes = new unsigned int[pScene->mNumMeshes];
+
+	for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+		pScene->mRootNode->mMeshes[i] = i;
+	}
+}
+
+#endif // !! ASSIMP_BUILD_NO_IRRMESH_IMPORTER
diff --git a/libs/assimp/code/AssetLib/Irr/IRRMeshLoader.h b/libs/assimp/code/AssetLib/Irr/IRRMeshLoader.h
new file mode 100644
index 0000000..79c1e48
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Irr/IRRMeshLoader.h
@@ -0,0 +1,94 @@
+/*
+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 IRRMeshLoader.h
+ *  @brief Declaration of the .irrMesh (Irrlight Engine Mesh Format)
+ *  importer class.
+ */
+#ifndef AI_IRRMESHLOADER_H_INCLUDED
+#define AI_IRRMESHLOADER_H_INCLUDED
+
+#include "IRRShared.h"
+#include <assimp/BaseImporter.h>
+
+#ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
+
+namespace Assimp {
+
+// ---------------------------------------------------------------------------
+/** IrrMesh importer class.
+ *
+ * IrrMesh is the native file format of the Irrlight engine and its editor
+ * irrEdit. As IrrEdit itself is capable of importing quite many file formats,
+ * it might be a good file format for data exchange.
+ */
+class IRRMeshImporter : public BaseImporter, public IrrlichtBase {
+public:
+    IRRMeshImporter();
+    ~IRRMeshImporter() override;
+
+    // -------------------------------------------------------------------
+    /** Returns whether the class can handle the format of the given file.
+     *  See BaseImporter::CanRead() for details.
+     */
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const override;
+
+protected:
+    // -------------------------------------------------------------------
+    /** Return importer meta information.
+     * See #BaseImporter::GetInfo for the details
+     */
+    const aiImporterDesc *GetInfo() const override;
+
+    // -------------------------------------------------------------------
+    /** Imports the given file into the given scene structure.
+     * See BaseImporter::InternReadFile() for details
+     */
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler) override;
+};
+
+} // end of namespace Assimp
+
+#endif // ASSIMP_BUILD_NO_IRRMESH_IMPORTER
+
+#endif // AI_IRRMESHIMPORTER_H_INC
diff --git a/libs/assimp/code/AssetLib/Irr/IRRShared.cpp b/libs/assimp/code/AssetLib/Irr/IRRShared.cpp
new file mode 100644
index 0000000..8763b63
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Irr/IRRShared.cpp
@@ -0,0 +1,387 @@
+/*
+---------------------------------------------------------------------------
+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  IRRShared.cpp
+ *  @brief Shared utilities for the IRR and IRRMESH loaders
+ */
+
+//This section should be excluded only if both the Irrlicht AND the Irrlicht Mesh importers were omitted.
+#if !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
+
+#include "IRRShared.h"
+#include <assimp/ParsingUtils.h>
+#include <assimp/fast_atof.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/material.h>
+
+using namespace Assimp;
+
+// Transformation matrix to convert from Assimp to IRR space
+const aiMatrix4x4 Assimp::AI_TO_IRR_MATRIX = aiMatrix4x4 (
+    1.0f, 0.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 1.0f, 0.0f,
+    0.0f, 1.0f, 0.0f, 0.0f,
+    0.0f, 0.0f, 0.0f, 1.0f);
+
+// ------------------------------------------------------------------------------------------------
+// read a property in hexadecimal format (i.e. ffffffff)
+void IrrlichtBase::ReadHexProperty(HexProperty &out ) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+        if (!ASSIMP_stricmp(attrib.name(), "name")) {
+            out.name = std::string( attrib.value() );
+        } else if (!ASSIMP_stricmp(attrib.name(),"value")) {
+            // parse the hexadecimal value
+			out.value = strtoul16(attrib.name());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a decimal property
+void IrrlichtBase::ReadIntProperty(IntProperty & out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+        } else if (!ASSIMP_stricmp(attrib.value(),"value")) {
+            // parse the int value
+			out.value = strtol10(attrib.name());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a string property
+void IrrlichtBase::ReadStringProperty( StringProperty& out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // simple copy the string
+			out.value = std::string(attrib.value());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a boolean property
+void IrrlichtBase::ReadBoolProperty(BoolProperty &out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")){
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // true or false, case insensitive
+			out.value = (ASSIMP_stricmp(attrib.value(), "true") ? false : true);
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a float property
+void IrrlichtBase::ReadFloatProperty(FloatProperty &out) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // just parse the float
+			out.value = fast_atof(attrib.value());
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// read a vector property
+void IrrlichtBase::ReadVectorProperty( VectorProperty &out ) {
+	for (pugi::xml_attribute attrib : mNode->attributes()) {
+		if (!ASSIMP_stricmp(attrib.name(), "name")) {
+			out.name = std::string(attrib.value());
+		} else if (!ASSIMP_stricmp(attrib.name(), "value")) {
+            // three floats, separated with commas
+            const char *ptr = attrib.value();
+
+            SkipSpaces(&ptr);
+            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.x );
+            SkipSpaces(&ptr);
+            if (',' != *ptr) {
+                ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
+			} else {
+				SkipSpaces(ptr + 1, &ptr);
+			}
+            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.y );
+            SkipSpaces(&ptr);
+            if (',' != *ptr) {
+                ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
+			} else {
+				SkipSpaces(ptr + 1, &ptr);
+			}
+            ptr = fast_atoreal_move<float>( ptr,(float&)out.value.z );
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Convert a string to a proper aiMappingMode
+int ConvertMappingMode(const std::string& mode) {
+    if (mode == "texture_clamp_repeat") {
+        return aiTextureMapMode_Wrap;
+	} else if (mode == "texture_clamp_mirror") {
+		return aiTextureMapMode_Mirror;
+	}
+
+    return aiTextureMapMode_Clamp;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Parse a material from the XML file
+aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags) {
+    aiMaterial* mat = new aiMaterial();
+    aiColor4D clr;
+    aiString s;
+
+    matFlags = 0; // zero output flags
+    int cnt  = 0; // number of used texture channels
+    unsigned int nd = 0;
+
+    for (pugi::xml_node child : mNode->children()) {
+		if (!ASSIMP_stricmp(child.name(), "color")) { // Hex properties
+			HexProperty prop;
+			ReadHexProperty(prop);
+			if (prop.name == "Diffuse") {
+				ColorFromARGBPacked(prop.value, clr);
+				mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_DIFFUSE);
+			} else if (prop.name == "Ambient") {
+				ColorFromARGBPacked(prop.value, clr);
+				mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_AMBIENT);
+			} else if (prop.name == "Specular") {
+				ColorFromARGBPacked(prop.value, clr);
+				mat->AddProperty(&clr, 1, AI_MATKEY_COLOR_SPECULAR);
+			}
+
+			// NOTE: The 'emissive' property causes problems. It is
+			// often != 0, even if there is obviously no light
+			// emitted by the described surface. In fact I think
+			// IRRLICHT ignores this property, too.
+#if 0
+            else if (prop.name == "Emissive") {
+                ColorFromARGBPacked(prop.value,clr);
+                mat->AddProperty(&clr,1,AI_MATKEY_COLOR_EMISSIVE);
+            }
+#endif
+		} else if (!ASSIMP_stricmp(child.name(), "float")) { // Float properties
+			FloatProperty prop;
+			ReadFloatProperty(prop);
+			if (prop.name == "Shininess") {
+				mat->AddProperty(&prop.value, 1, AI_MATKEY_SHININESS);
+			}
+		} else if (!ASSIMP_stricmp(child.name(), "bool")) { // Bool properties
+			BoolProperty prop;
+			ReadBoolProperty(prop);
+			if (prop.name == "Wireframe") {
+				int val = (prop.value ? true : false);
+				mat->AddProperty(&val, 1, AI_MATKEY_ENABLE_WIREFRAME);
+			} else if (prop.name == "GouraudShading") {
+				int val = (prop.value ? aiShadingMode_Gouraud : aiShadingMode_NoShading);
+				mat->AddProperty(&val, 1, AI_MATKEY_SHADING_MODEL);
+			} else if (prop.name == "BackfaceCulling") {
+				int val = (!prop.value);
+				mat->AddProperty(&val, 1, AI_MATKEY_TWOSIDED);
+			}
+		} else if (!ASSIMP_stricmp(child.name(), "texture") ||
+				   !ASSIMP_stricmp(child.name(), "enum")) { // String properties - textures and texture related properties
+			StringProperty prop;
+			ReadStringProperty(prop);
+			if (prop.value.length()) {
+				// material type (shader)
+				if (prop.name == "Type") {
+					if (prop.value == "solid") {
+						// default material ...
+					} else if (prop.value == "trans_vertex_alpha") {
+						matFlags = AI_IRRMESH_MAT_trans_vertex_alpha;
+					} else if (prop.value == "lightmap") {
+						matFlags = AI_IRRMESH_MAT_lightmap;
+					} else if (prop.value == "solid_2layer") {
+						matFlags = AI_IRRMESH_MAT_solid_2layer;
+					} else if (prop.value == "lightmap_m2") {
+						matFlags = AI_IRRMESH_MAT_lightmap_m2;
+					} else if (prop.value == "lightmap_m4") {
+						matFlags = AI_IRRMESH_MAT_lightmap_m4;
+					} else if (prop.value == "lightmap_light") {
+						matFlags = AI_IRRMESH_MAT_lightmap_light;
+					} else if (prop.value == "lightmap_light_m2") {
+						matFlags = AI_IRRMESH_MAT_lightmap_light_m2;
+					} else if (prop.value == "lightmap_light_m4") {
+						matFlags = AI_IRRMESH_MAT_lightmap_light_m4;
+					} else if (prop.value == "lightmap_add") {
+						matFlags = AI_IRRMESH_MAT_lightmap_add;
+					} else if (prop.value == "normalmap_solid" ||
+							   prop.value == "parallaxmap_solid") { // Normal and parallax maps are treated equally
+						matFlags = AI_IRRMESH_MAT_normalmap_solid;
+					} else if (prop.value == "normalmap_trans_vertex_alpha" ||
+							   prop.value == "parallaxmap_trans_vertex_alpha") {
+						matFlags = AI_IRRMESH_MAT_normalmap_tva;
+					} else if (prop.value == "normalmap_trans_add" ||
+							   prop.value == "parallaxmap_trans_add") {
+						matFlags = AI_IRRMESH_MAT_normalmap_ta;
+					} else {
+						ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: ", prop.value);
+					}
+				}
+
+				// Up to 4 texture channels are supported
+				if (prop.name == "Texture1") {
+					// Always accept the primary texture channel
+					++cnt;
+					s.Set(prop.value);
+					mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(0));
+				} else if (prop.name == "Texture2" && cnt == 1) {
+					// 2-layer material lightmapped?
+					if (matFlags & AI_IRRMESH_MAT_lightmap) {
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s, AI_MATKEY_TEXTURE_LIGHTMAP(0));
+
+						// set the corresponding material flag
+						matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+					} else if (matFlags & AI_IRRMESH_MAT_normalmap_solid) { // alternatively: normal or parallax mapping
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s, AI_MATKEY_TEXTURE_NORMALS(0));
+
+						// set the corresponding material flag
+						matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+					} else if (matFlags & AI_IRRMESH_MAT_solid_2layer) { // or just as second diffuse texture
+						++cnt;
+						s.Set(prop.value);
+						mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(1));
+						++nd;
+
+						// set the corresponding material flag
+						matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
+					} else {
+						ASSIMP_LOG_WARN("IRRmat: Skipping second texture");
+					}
+				} else if (prop.name == "Texture3" && cnt == 2) {
+					// Irrlicht does not seem to use these channels.
+					++cnt;
+					s.Set(prop.value);
+					mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 1));
+				} else if (prop.name == "Texture4" && cnt == 3) {
+					// Irrlicht does not seem to use these channels.
+					++cnt;
+					s.Set(prop.value);
+					mat->AddProperty(&s, AI_MATKEY_TEXTURE_DIFFUSE(nd + 2));
+				}
+
+				// Texture mapping options
+				if (prop.name == "TextureWrap1" && cnt >= 1) {
+					int map = ConvertMappingMode(prop.value);
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
+				} else if (prop.name == "TextureWrap2" && cnt >= 2) {
+					int map = ConvertMappingMode(prop.value);
+					if (matFlags & AI_IRRMESH_MAT_lightmap) {
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_LIGHTMAP(0));
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_LIGHTMAP(0));
+					} else if (matFlags & (AI_IRRMESH_MAT_normalmap_solid)) {
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_NORMALS(0));
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_NORMALS(0));
+					} else if (matFlags & AI_IRRMESH_MAT_solid_2layer) {
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(1));
+						mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(1));
+					}
+				} else if (prop.name == "TextureWrap3" && cnt >= 3) {
+					int map = ConvertMappingMode(prop.value);
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 1));
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 1));
+				} else if (prop.name == "TextureWrap4" && cnt >= 4) {
+					int map = ConvertMappingMode(prop.value);
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(nd + 2));
+					mat->AddProperty(&map, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(nd + 2));
+				}
+			}
+		}
+		//break;
+		/*case EXN_ELEMENT_END:
+
+                // Assume there are no further nested nodes in <material> elements
+                if ( !ASSIMP_stricmp(reader->getNodeName(),"material") ||
+                     !ASSIMP_stricmp(reader->getNodeName(),"attributes"))
+                {
+                    // Now process lightmapping flags
+                    // We should have at least one textur to do that ..
+                    if (cnt && matFlags & AI_IRRMESH_MAT_lightmap)
+                    {
+                        float f = 1.f;
+                        unsigned int unmasked = matFlags&~AI_IRRMESH_MAT_lightmap;
+
+                        // Additive lightmap?
+                        int op = (unmasked & AI_IRRMESH_MAT_lightmap_add
+                            ? aiTextureOp_Add : aiTextureOp_Multiply);
+
+                        // Handle Irrlicht's lightmapping scaling factor
+                        if (unmasked & AI_IRRMESH_MAT_lightmap_m2 ||
+                            unmasked & AI_IRRMESH_MAT_lightmap_light_m2)
+                        {
+                            f = 2.f;
+                        }
+                        else if (unmasked & AI_IRRMESH_MAT_lightmap_m4 ||
+                            unmasked & AI_IRRMESH_MAT_lightmap_light_m4)
+                        {
+                            f = 4.f;
+                        }
+                        mat->AddProperty( &f, 1, AI_MATKEY_TEXBLEND_LIGHTMAP(0));
+                        mat->AddProperty( &op,1, AI_MATKEY_TEXOP_LIGHTMAP(0));
+                    }
+
+                    return mat;
+                }
+            default:
+
+                // GCC complains here ...
+                break;
+        }
+    }*/
+	}
+    ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete");
+
+    return mat;
+}
+
+#endif // !(defined(ASSIMP_BUILD_NO_IRR_IMPORTER) && defined(ASSIMP_BUILD_NO_IRRMESH_IMPORTER))
diff --git a/libs/assimp/code/AssetLib/Irr/IRRShared.h b/libs/assimp/code/AssetLib/Irr/IRRShared.h
new file mode 100644
index 0000000..90e212d
--- /dev/null
+++ b/libs/assimp/code/AssetLib/Irr/IRRShared.h
@@ -0,0 +1,119 @@
+
+
+/** @file  IRRShared.h
+  * @brief Shared utilities for the IRR and IRRMESH loaders
+  */
+
+#ifndef INCLUDED_AI_IRRSHARED_H
+#define INCLUDED_AI_IRRSHARED_H
+
+#include <assimp/BaseImporter.h>
+#include <assimp/XmlParser.h>
+#include <cstdint>
+
+struct aiMaterial;
+
+namespace Assimp {
+
+/** @brief Matrix to convert from Assimp to IRR and backwards
+ */
+extern const aiMatrix4x4 AI_TO_IRR_MATRIX;
+
+// Default: 0 = solid, one texture
+#define AI_IRRMESH_MAT_solid_2layer 0x10000
+
+// Transparency flags
+#define AI_IRRMESH_MAT_trans_vertex_alpha 0x1
+#define AI_IRRMESH_MAT_trans_add 0x2
+
+// Lightmapping flags
+#define AI_IRRMESH_MAT_lightmap 0x2
+#define AI_IRRMESH_MAT_lightmap_m2 (AI_IRRMESH_MAT_lightmap | 0x4)
+#define AI_IRRMESH_MAT_lightmap_m4 (AI_IRRMESH_MAT_lightmap | 0x8)
+#define AI_IRRMESH_MAT_lightmap_light (AI_IRRMESH_MAT_lightmap | 0x10)
+#define AI_IRRMESH_MAT_lightmap_light_m2 (AI_IRRMESH_MAT_lightmap | 0x20)
+#define AI_IRRMESH_MAT_lightmap_light_m4 (AI_IRRMESH_MAT_lightmap | 0x40)
+#define AI_IRRMESH_MAT_lightmap_add (AI_IRRMESH_MAT_lightmap | 0x80)
+
+// Standard NormalMap (or Parallax map, they're treated equally)
+#define AI_IRRMESH_MAT_normalmap_solid (0x100)
+
+// Normal map combined with vertex alpha
+#define AI_IRRMESH_MAT_normalmap_tva \
+    (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_vertex_alpha)
+
+// Normal map combined with additive transparency
+#define AI_IRRMESH_MAT_normalmap_ta \
+    (AI_IRRMESH_MAT_normalmap_solid | AI_IRRMESH_MAT_trans_add)
+
+// Special flag. It indicates a second texture has been found
+// Its type depends ... either a normal textue or a normal map
+#define AI_IRRMESH_EXTRA_2ND_TEXTURE 0x100000
+
+// ---------------------------------------------------------------------------
+/** Base class for the Irr and IrrMesh importers.
+ *
+ *  Declares some irrlight-related xml parsing utilities and provides tools
+ *  to load materials from IRR and IRRMESH files.
+ */
+class IrrlichtBase {
+protected:
+    IrrlichtBase() :
+            mNode(nullptr) {
+        // empty
+    }
+
+    ~IrrlichtBase() {
+        // empty
+    }
+
+    /** @brief Data structure for a simple name-value property
+     */
+    template <class T>
+    struct Property {
+        std::string name;
+        T value;
+    };
+
+    typedef Property<uint32_t> HexProperty;
+    typedef Property<std::string> StringProperty;
+    typedef Property<bool> BoolProperty;
+    typedef Property<float> FloatProperty;
+    typedef Property<aiVector3D> VectorProperty;
+    typedef Property<int> IntProperty;
+
+    /// XML reader instance
+    XmlParser mParser;
+    pugi::xml_node *mNode;
+
+    // -------------------------------------------------------------------
+    /** Parse a material description from the XML
+     *  @return The created material
+     *  @param matFlags Receives AI_IRRMESH_MAT_XX flags
+     */
+    aiMaterial *ParseMaterial(unsigned int &matFlags);
+
+    // -------------------------------------------------------------------
+    /** Read a property of the specified type from the current XML element.
+     *  @param out Receives output data
+     */
+    void ReadHexProperty(HexProperty &out);
+    void ReadStringProperty(StringProperty &out);
+    void ReadBoolProperty(BoolProperty &out);
+    void ReadFloatProperty(FloatProperty &out);
+    void ReadVectorProperty(VectorProperty &out);
+    void ReadIntProperty(IntProperty &out);
+};
+
+// ------------------------------------------------------------------------------------------------
+// Unpack a hex color, e.g. 0xdcdedfff
+inline void ColorFromARGBPacked(uint32_t in, aiColor4D &clr) {
+    clr.a = ((in >> 24) & 0xff) / 255.f;
+    clr.r = ((in >> 16) & 0xff) / 255.f;
+    clr.g = ((in >> 8) & 0xff) / 255.f;
+    clr.b = ((in)&0xff) / 255.f;
+}
+
+} // end namespace Assimp
+
+#endif // !! INCLUDED_AI_IRRSHARED_H