diff --git a/CMakeLists.txt b/CMakeLists.txt
index c631b7685..6b350f6e3 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -134,6 +134,12 @@ OPTION ( ASSIMP_IGNORE_GIT_HASH
    OFF
 )
 
+IF ( WIN32 )
+    OPTION ( ASSIMP_BUILD_ASSIMP_VIEW 
+      "If the Assimp view tool is built. (requires DirectX)" 
+      OFF )
+ENDIF()
+
 IF (IOS AND NOT ASSIMP_HUNTER_ENABLED)
   IF (NOT CMAKE_BUILD_TYPE)
     SET(CMAKE_BUILD_TYPE "Release")
@@ -512,19 +518,19 @@ ENDIF()
 SET ( ASSIMP_BUILD_ARCHITECTURE "" CACHE STRING
   "describe the current architecture."
 )
-IF    ( ASSIMP_BUILD_ARCHITECTURE STREQUAL "")
-ELSE  ()
+IF( ASSIMP_BUILD_ARCHITECTURE STREQUAL "")
+ELSE()
   ADD_DEFINITIONS ( -D'ASSIMP_BUILD_ARCHITECTURE="${ASSIMP_BUILD_ARCHITECTURE}"' )
-ENDIF ()
+ENDIF()
 
 # ${CMAKE_GENERATOR}
 SET ( ASSIMP_BUILD_COMPILER "" CACHE STRING
   "describe the current compiler."
 )
-IF    ( ASSIMP_BUILD_COMPILER STREQUAL "")
-ELSE  ()
+IF( ASSIMP_BUILD_COMPILER STREQUAL "")
+ELSE()
   ADD_DEFINITIONS ( -D'ASSIMP_BUILD_COMPILER="${ASSIMP_BUILD_COMPILER}"' )
-ENDIF ()
+ENDIF()
 
 MARK_AS_ADVANCED ( ASSIMP_BUILD_ARCHITECTURE ASSIMP_BUILD_COMPILER )
 
diff --git a/code/AMF/AMFImporter.cpp b/code/AMF/AMFImporter.cpp
deleted file mode 100644
index df4324d4d..000000000
--- a/code/AMF/AMFImporter.cpp
+++ /dev/null
@@ -1,705 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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 AMFImporter.cpp
-/// \brief AMF-format files importer for Assimp: main algorithm implementation.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-
-// Header files, Assimp.
-#include "AMFImporter.hpp"
-#include "AMFImporter_Macro.hpp"
-
-#include <assimp/fast_atof.h>
-#include <assimp/DefaultIOSystem.h>
-
-// Header files, stdlib.
-#include <memory>
-
-namespace Assimp
-{
-
-/// \var aiImporterDesc AMFImporter::Description
-/// Conastant which hold importer description
-const aiImporterDesc AMFImporter::Description = {
-	"Additive manufacturing file format(AMF) Importer",
-	"smalcom",
-	"",
-	"See documentation in source code. Chapter: Limitations.",
-	aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
-	0,
-	0,
-	0,
-	0,
-	"amf"
-};
-
-void AMFImporter::Clear()
-{
-	mNodeElement_Cur = nullptr;
-	mUnit.clear();
-	mMaterial_Converted.clear();
-	mTexture_Converted.clear();
-	// Delete all elements
-	if(!mNodeElement_List.empty())
-	{
-		for(CAMFImporter_NodeElement* ne: mNodeElement_List) { delete ne; }
-
-		mNodeElement_List.clear();
-	}
-}
-
-AMFImporter::~AMFImporter()
-{
-	if(mReader != nullptr) delete mReader;
-	// Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
-	Clear();
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: find set ************************************************************/
-/*********************************************************************************************************************************************/
-
-bool AMFImporter::Find_NodeElement(const std::string& pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement** pNodeElement) const
-{
-	for(CAMFImporter_NodeElement* ne: mNodeElement_List)
-	{
-		if((ne->ID == pID) && (ne->Type == pType))
-		{
-			if(pNodeElement != nullptr) *pNodeElement = ne;
-
-			return true;
-		}
-	}// for(CAMFImporter_NodeElement* ne: mNodeElement_List)
-
-	return false;
-}
-
-bool AMFImporter::Find_ConvertedNode(const std::string& pID, std::list<aiNode*>& pNodeList, aiNode** pNode) const
-{
-aiString node_name(pID.c_str());
-
-	for(aiNode* node: pNodeList)
-	{
-		if(node->mName == node_name)
-		{
-			if(pNode != nullptr) *pNode = node;
-
-			return true;
-		}
-	}// for(aiNode* node: pNodeList)
-
-	return false;
-}
-
-bool AMFImporter::Find_ConvertedMaterial(const std::string& pID, const SPP_Material** pConvertedMaterial) const
-{
-	for(const SPP_Material& mat: mMaterial_Converted)
-	{
-		if(mat.ID == pID)
-		{
-			if(pConvertedMaterial != nullptr) *pConvertedMaterial = &mat;
-
-			return true;
-		}
-	}// for(const SPP_Material& mat: mMaterial_Converted)
-
-	return false;
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: throw set ***********************************************************/
-/*********************************************************************************************************************************************/
-
-void AMFImporter::Throw_CloseNotFound(const std::string& pNode)
-{
-	throw DeadlyImportError("Close tag for node <" + pNode + "> not found. Seems file is corrupt.");
-}
-
-void AMFImporter::Throw_IncorrectAttr(const std::string& pAttrName)
-{
-	throw DeadlyImportError("Node <" + std::string(mReader->getNodeName()) + "> has incorrect attribute \"" + pAttrName + "\".");
-}
-
-void AMFImporter::Throw_IncorrectAttrValue(const std::string& pAttrName)
-{
-	throw DeadlyImportError("Attribute \"" + pAttrName + "\" in node <" + std::string(mReader->getNodeName()) + "> has incorrect value.");
-}
-
-void AMFImporter::Throw_MoreThanOnceDefined(const std::string& pNodeType, const std::string& pDescription)
-{
-	throw DeadlyImportError("\"" + pNodeType + "\" node can be used only once in " + mReader->getNodeName() + ". Description: " + pDescription);
-}
-
-void AMFImporter::Throw_ID_NotFound(const std::string& pID) const
-{
-	throw DeadlyImportError("Not found node with name \"" + pID + "\".");
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************* Functions: XML set ************************************************************/
-/*********************************************************************************************************************************************/
-
-void AMFImporter::XML_CheckNode_MustHaveChildren()
-{
-	if(mReader->isEmptyElement()) throw DeadlyImportError(std::string("Node <") + mReader->getNodeName() + "> must have children.");
-}
-
-void AMFImporter::XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
-{
-    static const size_t Uns_Skip_Len = 3;
-    const char* Uns_Skip[Uns_Skip_Len] = { "composite", "edge", "normal" };
-
-    static bool skipped_before[Uns_Skip_Len] = { false, false, false };
-
-    std::string nn(mReader->getNodeName());
-    bool found = false;
-    bool close_found = false;
-    size_t sk_idx;
-
-	for(sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++)
-	{
-		if(nn != Uns_Skip[sk_idx]) continue;
-
-		found = true;
-		if(mReader->isEmptyElement())
-		{
-			close_found = true;
-
-			goto casu_cres;
-		}
-
-		while(mReader->read())
-		{
-			if((mReader->getNodeType() == irr::io::EXN_ELEMENT_END) && (nn == mReader->getNodeName()))
-			{
-				close_found = true;
-
-				goto casu_cres;
-			}
-		}
-	}// for(sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++)
-
-casu_cres:
-
-	if(!found) throw DeadlyImportError("Unknown node \"" + nn + "\" in " + pParentNodeName + ".");
-	if(!close_found) Throw_CloseNotFound(nn);
-
-	if(!skipped_before[sk_idx])
-	{
-		skipped_before[sk_idx] = true;
-        ASSIMP_LOG_WARN_F("Skipping node \"", nn, "\" in ", pParentNodeName, ".");
-	}
-}
-
-bool AMFImporter::XML_SearchNode(const std::string& pNodeName)
-{
-	while(mReader->read())
-	{
-		if((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true;
-	}
-
-	return false;
-}
-
-bool AMFImporter::XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
-{
-    std::string val(mReader->getAttributeValue(pAttrIdx));
-
-	if((val == "false") || (val == "0"))
-		return false;
-	else if((val == "true") || (val == "1"))
-		return true;
-	else
-		throw DeadlyImportError("Bool attribute value can contain \"false\"/\"0\" or \"true\"/\"1\" not the \"" + val + "\"");
-}
-
-float AMFImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
-{
-    std::string val;
-    float tvalf;
-
-	ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val);
-	fast_atoreal_move(val.c_str(), tvalf, false);
-
-	return tvalf;
-}
-
-uint32_t AMFImporter::XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx)
-{
-	return strtoul10(mReader->getAttributeValue(pAttrIdx));
-}
-
-float AMFImporter::XML_ReadNode_GetVal_AsFloat()
-{
-    std::string val;
-    float tvalf;
-
-	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. No data, seems file is corrupt.");
-	if(mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. Invalid type of XML element, seems file is corrupt.");
-
-	ParseHelper_FixTruncatedFloatString(mReader->getNodeData(), val);
-	fast_atoreal_move(val.c_str(), tvalf, false);
-
-	return tvalf;
-}
-
-uint32_t AMFImporter::XML_ReadNode_GetVal_AsU32()
-{
-	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. No data, seems file is corrupt.");
-	if(mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. Invalid type of XML element, seems file is corrupt.");
-
-	return strtoul10(mReader->getNodeData());
-}
-
-void AMFImporter::XML_ReadNode_GetVal_AsString(std::string& pValue)
-{
-	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsString. No data, seems file is corrupt.");
-	if(mReader->getNodeType() != irr::io::EXN_TEXT)
-		throw DeadlyImportError("XML_ReadNode_GetVal_AsString. Invalid type of XML element, seems file is corrupt.");
-
-	pValue = mReader->getNodeData();
-}
-
-/*********************************************************************************************************************************************/
-/************************************************************ Functions: parse set ***********************************************************/
-/*********************************************************************************************************************************************/
-
-void AMFImporter::ParseHelper_Node_Enter(CAMFImporter_NodeElement* pNode)
-{
-	mNodeElement_Cur->Child.push_back(pNode);// add new element to current element child list.
-	mNodeElement_Cur = pNode;// switch current element to new one.
-}
-
-void AMFImporter::ParseHelper_Node_Exit()
-{
-	// check if we can walk up.
-	if(mNodeElement_Cur != nullptr) mNodeElement_Cur = mNodeElement_Cur->Parent;
-}
-
-void AMFImporter::ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
-{
-    size_t instr_len;
-
-	pOutString.clear();
-	instr_len = strlen(pInStr);
-	if(!instr_len) return;
-
-	pOutString.reserve(instr_len * 3 / 2);
-	// check and correct floats in format ".x". Must be "x.y".
-	if(pInStr[0] == '.') pOutString.push_back('0');
-
-	pOutString.push_back(pInStr[0]);
-	for(size_t ci = 1; ci < instr_len; ci++)
-	{
-		if((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t')))
-		{
-			pOutString.push_back('0');
-			pOutString.push_back('.');
-		}
-		else
-		{
-			pOutString.push_back(pInStr[ci]);
-		}
-	}
-}
-
-static bool ParseHelper_Decode_Base64_IsBase64(const char pChar)
-{
-	return (isalnum(pChar) || (pChar == '+') || (pChar == '/'));
-}
-
-void AMFImporter::ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const
-{
-    // With help from
-    // René Nyffenegger http://www.adp-gmbh.ch/cpp/common/base64.html
-    const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-
-    uint8_t tidx = 0;
-    uint8_t arr4[4], arr3[3];
-
-	// check input data
-	if(pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
-	// prepare output place
-	pOutputData.clear();
-	pOutputData.reserve(pInputBase64.size() / 4 * 3);
-
-	for(size_t in_len = pInputBase64.size(), in_idx = 0; (in_len > 0) && (pInputBase64[in_idx] != '='); in_len--)
-	{
-		if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx]))
-		{
-			arr4[tidx++] = pInputBase64[in_idx++];
-			if(tidx == 4)
-			{
-				for(tidx = 0; tidx < 4; tidx++) arr4[tidx] = (uint8_t)base64_chars.find(arr4[tidx]);
-
-				arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
-				arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
-				arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
-				for(tidx = 0; tidx < 3; tidx++) pOutputData.push_back(arr3[tidx]);
-
-				tidx = 0;
-			}// if(tidx == 4)
-		}// if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx]))
-		else
-		{
-			in_idx++;
-		}// if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx])) else
-	}
-
-	if(tidx)
-	{
-		for(uint8_t i = tidx; i < 4; i++) arr4[i] = 0;
-		for(uint8_t i = 0; i < 4; i++) arr4[i] = (uint8_t)(base64_chars.find(arr4[i]));
-
-		arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
-		arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
-		arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
-		for(uint8_t i = 0; i < (tidx - 1); i++) pOutputData.push_back(arr3[i]);
-	}
-}
-
-void AMFImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler)
-{
-    irr::io::IrrXMLReader* OldReader = mReader;// store current XMLreader.
-    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
-
-	// Check whether we can read from the file
-	if(file.get() == NULL) throw DeadlyImportError("Failed to open AMF file " + pFile + ".");
-
-	// generate a XML reader for it
-	std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
-	mReader = irr::io::createIrrXMLReader(mIOWrapper.get());
-	if(!mReader) throw DeadlyImportError("Failed to create XML reader for file" + pFile + ".");
-	//
-	// start reading
-	// search for root tag <amf>
-	if(XML_SearchNode("amf"))
-		ParseNode_Root();
-	else
-		throw DeadlyImportError("Root node \"amf\" not found.");
-
-	delete mReader;
-	// restore old XMLreader
-	mReader = OldReader;
-}
-
-// <amf
-// unit="" - The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
-// version="" - Version of file format.
-// >
-// </amf>
-// Root XML element.
-// Multi elements - No.
-void AMFImporter::ParseNode_Root()
-{
-    std::string unit, version;
-    CAMFImporter_NodeElement *ne( nullptr );
-
-	// Read attributes for node <amf>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("unit", unit, mReader->getAttributeValue);
-		MACRO_ATTRREAD_CHECK_RET("version", version, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND_WSKIP;
-
-	// Check attributes
-	if(!mUnit.empty())
-	{
-		if((mUnit != "inch") && (mUnit != "millimeter") && (mUnit != "meter") && (mUnit != "feet") && (mUnit != "micron")) Throw_IncorrectAttrValue("unit");
-	}
-
-	// create root node element.
-	ne = new CAMFImporter_NodeElement_Root(nullptr);
-	mNodeElement_Cur = ne;// set first "current" element
-	// and assign attribute's values
-	((CAMFImporter_NodeElement_Root*)ne)->Unit = unit;
-	((CAMFImporter_NodeElement_Root*)ne)->Version = version;
-
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		MACRO_NODECHECK_LOOPBEGIN("amf");
-			if(XML_CheckNode_NameEqual("object")) { ParseNode_Object(); continue; }
-			if(XML_CheckNode_NameEqual("material")) { ParseNode_Material(); continue; }
-			if(XML_CheckNode_NameEqual("texture")) { ParseNode_Texture(); continue; }
-			if(XML_CheckNode_NameEqual("constellation")) { ParseNode_Constellation(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("amf");
-		mNodeElement_Cur = ne;// force restore "current" element
-	}// if(!mReader->isEmptyElement())
-
-	mNodeElement_List.push_back(ne);// add to node element list because its a new object in graph.
-}
-
-// <constellation
-// id="" - The Object ID of the new constellation being defined.
-// >
-// </constellation>
-// A collection of objects or constellations with specific relative locations.
-// Multi elements - Yes.
-// Parent element - <amf>.
-void AMFImporter::ParseNode_Constellation()
-{
-    std::string id;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// Read attributes for node <constellation>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create and if needed - define new grouping object.
-	ne = new CAMFImporter_NodeElement_Constellation(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Constellation& als = *((CAMFImporter_NodeElement_Constellation*)ne);// alias for convenience
-
-	if(!id.empty()) als.ID = id;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("constellation");
-			if(XML_CheckNode_NameEqual("instance")) { ParseNode_Instance(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("constellation");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <instance
-// objectid="" - The Object ID of the new constellation being defined.
-// >
-// </instance>
-// A collection of objects or constellations with specific relative locations.
-// Multi elements - Yes.
-// Parent element - <amf>.
-void AMFImporter::ParseNode_Instance()
-{
-    std::string objectid;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// Read attributes for node <constellation>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("objectid", objectid, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// used object id must be defined, check that.
-	if(objectid.empty()) throw DeadlyImportError("\"objectid\" in <instance> must be defined.");
-	// create and define new grouping object.
-	ne = new CAMFImporter_NodeElement_Instance(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Instance& als = *((CAMFImporter_NodeElement_Instance*)ne);// alias for convenience
-
-	als.ObjectID = objectid;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool read_flag[6] = { false, false, false, false, false, false };
-
-		als.Delta.Set(0, 0, 0);
-		als.Rotation.Set(0, 0, 0);
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("instance");
-			MACRO_NODECHECK_READCOMP_F("deltax", read_flag[0], als.Delta.x);
-			MACRO_NODECHECK_READCOMP_F("deltay", read_flag[1], als.Delta.y);
-			MACRO_NODECHECK_READCOMP_F("deltaz", read_flag[2], als.Delta.z);
-			MACRO_NODECHECK_READCOMP_F("rx", read_flag[3], als.Rotation.x);
-			MACRO_NODECHECK_READCOMP_F("ry", read_flag[4], als.Rotation.y);
-			MACRO_NODECHECK_READCOMP_F("rz", read_flag[5], als.Rotation.z);
-		MACRO_NODECHECK_LOOPEND("instance");
-		ParseHelper_Node_Exit();
-		// also convert degrees to radians.
-		als.Rotation.x = AI_MATH_PI_F * als.Rotation.x / 180.0f;
-		als.Rotation.y = AI_MATH_PI_F * als.Rotation.y / 180.0f;
-		als.Rotation.z = AI_MATH_PI_F * als.Rotation.z / 180.0f;
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <object
-// id="" - A unique ObjectID for the new object being defined.
-// >
-// </object>
-// An object definition.
-// Multi elements - Yes.
-// Parent element - <amf>.
-void AMFImporter::ParseNode_Object()
-{
-    std::string id;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// Read attributes for node <object>.
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-
-	// create and if needed - define new geometry object.
-	ne = new CAMFImporter_NodeElement_Object(mNodeElement_Cur);
-
-	CAMFImporter_NodeElement_Object& als = *((CAMFImporter_NodeElement_Object*)ne);// alias for convenience
-
-	if(!id.empty()) als.ID = id;
-	// Check for child nodes
-	if(!mReader->isEmptyElement())
-	{
-		bool col_read = false;
-
-		ParseHelper_Node_Enter(ne);
-		MACRO_NODECHECK_LOOPBEGIN("object");
-			if(XML_CheckNode_NameEqual("color"))
-			{
-				// Check if color already defined for object.
-				if(col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <object>.");
-				// read data and set flag about it
-				ParseNode_Color();
-				col_read = true;
-
-				continue;
-			}
-
-			if(XML_CheckNode_NameEqual("mesh")) { ParseNode_Mesh(); continue; }
-			if(XML_CheckNode_NameEqual("metadata")) { ParseNode_Metadata(); continue; }
-		MACRO_NODECHECK_LOOPEND("object");
-		ParseHelper_Node_Exit();
-	}// if(!mReader->isEmptyElement())
-	else
-	{
-		mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	}// if(!mReader->isEmptyElement()) else
-
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-// <metadata
-// type="" - The type of the attribute.
-// >
-// </metadata>
-// Specify additional information about an entity.
-// Multi elements - Yes.
-// Parent element - <amf>, <object>, <volume>, <material>, <vertex>.
-//
-// Reserved types are:
-// "Name" - The alphanumeric label of the entity, to be used by the interpreter if interacting with the user.
-// "Description" - A description of the content of the entity
-// "URL" - A link to an external resource relating to the entity
-// "Author" - Specifies the name(s) of the author(s) of the entity
-// "Company" - Specifying the company generating the entity
-// "CAD" - specifies the name of the originating CAD software and version
-// "Revision" - specifies the revision of the entity
-// "Tolerance" - specifies the desired manufacturing tolerance of the entity in entity's unit system
-// "Volume" - specifies the total volume of the entity, in the entity's unit system, to be used for verification (object and volume only)
-void AMFImporter::ParseNode_Metadata()
-{
-    std::string type, value;
-    CAMFImporter_NodeElement* ne( nullptr );
-
-	// read attribute
-	MACRO_ATTRREAD_LOOPBEG;
-		MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
-	MACRO_ATTRREAD_LOOPEND;
-	// and value of node.
-	value = mReader->getNodeData();
-	// Create node element and assign read data.
-	ne = new CAMFImporter_NodeElement_Metadata(mNodeElement_Cur);
-	((CAMFImporter_NodeElement_Metadata*)ne)->Type = type;
-	((CAMFImporter_NodeElement_Metadata*)ne)->Value = value;
-	mNodeElement_Cur->Child.push_back(ne);// Add element to child list of current element
-	mNodeElement_List.push_back(ne);// and to node element list because its a new object in graph.
-}
-
-/*********************************************************************************************************************************************/
-/******************************************************** Functions: BaseImporter set ********************************************************/
-/*********************************************************************************************************************************************/
-
-bool AMFImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const
-{
-    const std::string extension = GetExtension(pFile);
-
-    if ( extension == "amf" ) {
-        return true;
-    }
-
-	if(!extension.length() || pCheckSig)
-	{
-		const char* tokens[] = { "<amf" };
-
-		return SearchFileHeaderForToken( pIOHandler, pFile, tokens, 1 );
-	}
-
-	return false;
-}
-
-void AMFImporter::GetExtensionList(std::set<std::string>& pExtensionList)
-{
-	pExtensionList.insert("amf");
-}
-
-const aiImporterDesc* AMFImporter::GetInfo () const
-{
-	return &Description;
-}
-
-void AMFImporter::InternReadFile(const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-	Clear();// delete old graph.
-	ParseFile(pFile, pIOHandler);
-	Postprocess_BuildScene(pScene);
-	// scene graph is ready, exit.
-}
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/code/AMF/AMFImporter_Postprocess.cpp b/code/AMF/AMFImporter_Postprocess.cpp
deleted file mode 100644
index 273b8e0c4..000000000
--- a/code/AMF/AMFImporter_Postprocess.cpp
+++ /dev/null
@@ -1,978 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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 AMFImporter_Postprocess.cpp
-/// \brief Convert built scenegraph and objects to Assimp scenegraph.
-/// \date 2016
-/// \author smal.root@gmail.com
-
-#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-
-#include "AMFImporter.hpp"
-
-// Header files, Assimp.
-#include <assimp/SceneCombiner.h>
-#include <assimp/StandardShapes.h>
-#include <assimp/StringUtils.h>
-
-// Header files, stdlib.
-#include <iterator>
-
-namespace Assimp
-{
-
-aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*pY*/, const float /*pZ*/) const
-{
-    aiColor4D tcol;
-
-	// Check if stored data are supported.
-	if(!Composition.empty())
-	{
-		throw DeadlyImportError("IME. GetColor for composition");
-	}
-	else if(Color->Composed)
-	{
-		throw DeadlyImportError("IME. GetColor, composed color");
-	}
-	else
-	{
-		tcol = Color->Color;
-	}
-
-	// Check if default color must be used
-	if((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0))
-	{
-		tcol.r = 0.5f;
-		tcol.g = 0.5f;
-		tcol.b = 0.5f;
-		tcol.a = 1;
-	}
-
-	return tcol;
-}
-
-void AMFImporter::PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
-														std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const
-{
-    CAMFImporter_NodeElement_Vertices* vn = nullptr;
-    size_t col_idx;
-
-	// All data stored in "vertices", search for it.
-	for(CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-	{
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Vertices) vn = (CAMFImporter_NodeElement_Vertices*)ne_child;
-	}
-
-	// If "vertices" not found then no work for us.
-	if(vn == nullptr) return;
-
-	pVertexCoordinateArray.reserve(vn->Child.size());// all coordinates stored as child and we need to reserve space for future push_back's.
-	pVertexColorArray.resize(vn->Child.size());// colors count equal vertices count.
-	col_idx = 0;
-	// Inside vertices collect all data and place to arrays
-	for(CAMFImporter_NodeElement* vn_child: vn->Child)
-	{
-		// vertices, colors
-		if(vn_child->Type == CAMFImporter_NodeElement::ENET_Vertex)
-		{
-			// by default clear color for current vertex
-			pVertexColorArray[col_idx] = nullptr;
-
-			for(CAMFImporter_NodeElement* vtx: vn_child->Child)
-			{
-				if(vtx->Type == CAMFImporter_NodeElement::ENET_Coordinates)
-				{
-					pVertexCoordinateArray.push_back(((CAMFImporter_NodeElement_Coordinates*)vtx)->Coordinate);
-
-					continue;
-				}
-
-				if(vtx->Type == CAMFImporter_NodeElement::ENET_Color)
-				{
-					pVertexColorArray[col_idx] = (CAMFImporter_NodeElement_Color*)vtx;
-
-					continue;
-				}
-			}// for(CAMFImporter_NodeElement* vtx: vn_child->Child)
-
-			col_idx++;
-		}// if(vn_child->Type == CAMFImporter_NodeElement::ENET_Vertex)
-	}// for(CAMFImporter_NodeElement* vn_child: vn->Child)
-}
-
-size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B,
-																const std::string& pID_A)
-{
-    size_t TextureConverted_Index;
-    std::string TextureConverted_ID;
-
-	// check input data
-	if(pID_R.empty() && pID_G.empty() && pID_B.empty() && pID_A.empty())
-		throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. At least one texture ID must be defined.");
-
-	// Create ID
-	TextureConverted_ID = pID_R + "_" + pID_G + "_" + pID_B + "_" + pID_A;
-	// Check if texture specified by set of IDs is converted already.
-	TextureConverted_Index = 0;
-	for(const SPP_Texture& tex_convd: mTexture_Converted)
-	{
-        if ( tex_convd.ID == TextureConverted_ID ) {
-            return TextureConverted_Index;
-        } else {
-            ++TextureConverted_Index;
-        }
-	}
-
-	//
-	// Converted texture not found, create it.
-	//
-	CAMFImporter_NodeElement_Texture* src_texture[4]{nullptr};
-	std::vector<CAMFImporter_NodeElement_Texture*> src_texture_4check;
-	SPP_Texture converted_texture;
-
-	{// find all specified source textures
-		CAMFImporter_NodeElement* t_tex;
-
-		// R
-		if(!pID_R.empty())
-		{
-			if(!Find_NodeElement(pID_R, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_R);
-
-			src_texture[0] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[0] = nullptr;
-		}
-
-		// G
-		if(!pID_G.empty())
-		{
-			if(!Find_NodeElement(pID_G, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_G);
-
-			src_texture[1] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[1] = nullptr;
-		}
-
-		// B
-		if(!pID_B.empty())
-		{
-			if(!Find_NodeElement(pID_B, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_B);
-
-			src_texture[2] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[2] = nullptr;
-		}
-
-		// A
-		if(!pID_A.empty())
-		{
-			if(!Find_NodeElement(pID_A, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_A);
-
-			src_texture[3] = (CAMFImporter_NodeElement_Texture*)t_tex;
-			src_texture_4check.push_back((CAMFImporter_NodeElement_Texture*)t_tex);
-		}
-		else
-		{
-			src_texture[3] = nullptr;
-		}
-	}// END: find all specified source textures
-
-	// check that all textures has same size
-	if(src_texture_4check.size() > 1)
-	{
-		for (size_t i = 0, i_e = (src_texture_4check.size() - 1); i < i_e; i++)
-		{
-			if((src_texture_4check[i]->Width != src_texture_4check[i + 1]->Width) || (src_texture_4check[i]->Height != src_texture_4check[i + 1]->Height) ||
-				(src_texture_4check[i]->Depth != src_texture_4check[i + 1]->Depth))
-			{
-				throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. Source texture must has the same size.");
-			}
-		}
-	}// if(src_texture_4check.size() > 1)
-
-	// set texture attributes
-	converted_texture.Width = src_texture_4check[0]->Width;
-	converted_texture.Height = src_texture_4check[0]->Height;
-	converted_texture.Depth = src_texture_4check[0]->Depth;
-	// if one of source texture is tiled then converted texture is tiled too.
-	converted_texture.Tiled = false;
-	for(uint8_t i = 0; i < src_texture_4check.size(); i++) converted_texture.Tiled |= src_texture_4check[i]->Tiled;
-
-	// Create format hint.
-	strcpy(converted_texture.FormatHint, "rgba0000");// copy initial string.
-	if(!pID_R.empty()) converted_texture.FormatHint[4] = '8';
-	if(!pID_G.empty()) converted_texture.FormatHint[5] = '8';
-	if(!pID_B.empty()) converted_texture.FormatHint[6] = '8';
-	if(!pID_A.empty()) converted_texture.FormatHint[7] = '8';
-
-	//
-	// Сopy data of textures.
-	//
-	size_t tex_size = 0;
-	size_t step = 0;
-	size_t off_g = 0;
-	size_t off_b = 0;
-
-	// Calculate size of the target array and rule how data will be copied.
-    if(!pID_R.empty() && nullptr != src_texture[ 0 ] ) {
-        tex_size += src_texture[0]->Data.size(); step++, off_g++, off_b++;
-    }
-    if(!pID_G.empty() && nullptr != src_texture[ 1 ] ) {
-        tex_size += src_texture[1]->Data.size(); step++, off_b++;
-    }
-    if(!pID_B.empty() && nullptr != src_texture[ 2 ] ) {
-        tex_size += src_texture[2]->Data.size(); step++;
-    }
-    if(!pID_A.empty() && nullptr != src_texture[ 3 ] ) {
-        tex_size += src_texture[3]->Data.size(); step++;
-    }
-
-    // Create target array.
-	converted_texture.Data = new uint8_t[tex_size];
-	// And copy data
-	auto CopyTextureData = [&](const std::string& pID, const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void
-	{
-		if(!pID.empty())
-		{
-			for(size_t idx_target = pOffset, idx_src = 0; idx_target < tex_size; idx_target += pStep, idx_src++) {
-				CAMFImporter_NodeElement_Texture* tex = src_texture[pSrcTexNum];
-				ai_assert(tex);
-				converted_texture.Data[idx_target] = tex->Data.at(idx_src);
-			}
-		}
-	};// auto CopyTextureData = [&](const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void
-
-	CopyTextureData(pID_R, 0, step, 0);
-	CopyTextureData(pID_G, off_g, step, 1);
-	CopyTextureData(pID_B, off_b, step, 2);
-	CopyTextureData(pID_A, step - 1, step, 3);
-
-	// Store new converted texture ID
-	converted_texture.ID = TextureConverted_ID;
-	// Store new converted texture
-	mTexture_Converted.push_back(converted_texture);
-
-	return TextureConverted_Index;
-}
-
-void AMFImporter::PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> >& pOutputList_Separated)
-{
-    auto texmap_is_equal = [](const CAMFImporter_NodeElement_TexMap* pTexMap1, const CAMFImporter_NodeElement_TexMap* pTexMap2) -> bool
-    {
-	    if((pTexMap1 == nullptr) && (pTexMap2 == nullptr)) return true;
-	    if(pTexMap1 == nullptr) return false;
-	    if(pTexMap2 == nullptr) return false;
-
-	    if(pTexMap1->TextureID_R != pTexMap2->TextureID_R) return false;
-	    if(pTexMap1->TextureID_G != pTexMap2->TextureID_G) return false;
-	    if(pTexMap1->TextureID_B != pTexMap2->TextureID_B) return false;
-	    if(pTexMap1->TextureID_A != pTexMap2->TextureID_A) return false;
-
-	    return true;
-    };
-
-	pOutputList_Separated.clear();
-	if(pInputList.empty()) return;
-
-	do
-	{
-		SComplexFace face_start = pInputList.front();
-		std::list<SComplexFace> face_list_cur;
-
-		for(std::list<SComplexFace>::iterator it = pInputList.begin(), it_end = pInputList.end(); it != it_end;)
-		{
-			if(texmap_is_equal(face_start.TexMap, it->TexMap))
-			{
-				auto it_old = it;
-
-				++it;
-				face_list_cur.push_back(*it_old);
-				pInputList.erase(it_old);
-			}
-			else
-			{
-				++it;
-			}
-		}
-
-		if(!face_list_cur.empty()) pOutputList_Separated.push_back(face_list_cur);
-
-	} while(!pInputList.empty());
-}
-
-void AMFImporter::Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata*>& metadataList, aiNode& sceneNode) const
-{
-	if ( !metadataList.empty() )
-	{
-		if(sceneNode.mMetaData != nullptr) throw DeadlyImportError("Postprocess. MetaData member in node are not nullptr. Something went wrong.");
-
-		// copy collected metadata to output node.
-        sceneNode.mMetaData = aiMetadata::Alloc( static_cast<unsigned int>(metadataList.size()) );
-		size_t meta_idx( 0 );
-
-		for(const CAMFImporter_NodeElement_Metadata& metadata: metadataList)
-		{
-			sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata.Type, aiString(metadata.Value));
-		}
-	}// if(!metadataList.empty())
-}
-
-void AMFImporter::Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object& pNodeElement, std::list<aiMesh*>& pMeshList, aiNode** pSceneNode)
-{
-CAMFImporter_NodeElement_Color* object_color = nullptr;
-
-	// create new aiNode and set name as <object> has.
-	*pSceneNode = new aiNode;
-	(*pSceneNode)->mName = pNodeElement.ID;
-	// read mesh and color
-	for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-	{
-		std::vector<aiVector3D> vertex_arr;
-		std::vector<CAMFImporter_NodeElement_Color*> color_arr;
-
-		// color for object
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Color) object_color = (CAMFImporter_NodeElement_Color*)ne_child;
-
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Mesh)
-		{
-			// Create arrays from children of mesh: vertices.
-			PostprocessHelper_CreateMeshDataArray(*((CAMFImporter_NodeElement_Mesh*)ne_child), vertex_arr, color_arr);
-			// Use this arrays as a source when creating every aiMesh
-			Postprocess_BuildMeshSet(*((CAMFImporter_NodeElement_Mesh*)ne_child), vertex_arr, color_arr, object_color, pMeshList, **pSceneNode);
-		}
-	}// for(const CAMFImporter_NodeElement* ne_child: pNodeElement)
-}
-
-void AMFImporter::Postprocess_BuildMeshSet(const CAMFImporter_NodeElement_Mesh& pNodeElement, const std::vector<aiVector3D>& pVertexCoordinateArray,
-											const std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray,
-											const CAMFImporter_NodeElement_Color* pObjectColor, std::list<aiMesh*>& pMeshList, aiNode& pSceneNode)
-{
-std::list<unsigned int> mesh_idx;
-
-	// all data stored in "volume", search for it.
-	for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-	{
-		const CAMFImporter_NodeElement_Color* ne_volume_color = nullptr;
-		const SPP_Material* cur_mat = nullptr;
-
-		if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
-		{
-			/******************* Get faces *******************/
-			const CAMFImporter_NodeElement_Volume* ne_volume = reinterpret_cast<const CAMFImporter_NodeElement_Volume*>(ne_child);
-
-			std::list<SComplexFace> complex_faces_list;// List of the faces of the volume.
-			std::list<std::list<SComplexFace> > complex_faces_toplist;// List of the face list for every mesh.
-
-			// check if volume use material
-			if(!ne_volume->MaterialID.empty())
-			{
-				if(!Find_ConvertedMaterial(ne_volume->MaterialID, &cur_mat)) Throw_ID_NotFound(ne_volume->MaterialID);
-			}
-
-			// inside "volume" collect all data and place to arrays or create new objects
-			for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
-			{
-				// color for volume
-				if(ne_volume_child->Type == CAMFImporter_NodeElement::ENET_Color)
-				{
-					ne_volume_color = reinterpret_cast<const CAMFImporter_NodeElement_Color*>(ne_volume_child);
-				}
-				else if(ne_volume_child->Type == CAMFImporter_NodeElement::ENET_Triangle)// triangles, triangles colors
-				{
-					const CAMFImporter_NodeElement_Triangle& tri_al = *reinterpret_cast<const CAMFImporter_NodeElement_Triangle*>(ne_volume_child);
-
-					SComplexFace complex_face;
-
-					// initialize pointers
-					complex_face.Color = nullptr;
-					complex_face.TexMap = nullptr;
-					// get data from triangle children: color, texture coordinates.
-					if(tri_al.Child.size())
-					{
-						for(const CAMFImporter_NodeElement* ne_triangle_child: tri_al.Child)
-						{
-							if(ne_triangle_child->Type == CAMFImporter_NodeElement::ENET_Color)
-								complex_face.Color = reinterpret_cast<const CAMFImporter_NodeElement_Color*>(ne_triangle_child);
-							else if(ne_triangle_child->Type == CAMFImporter_NodeElement::ENET_TexMap)
-								complex_face.TexMap = reinterpret_cast<const CAMFImporter_NodeElement_TexMap*>(ne_triangle_child);
-						}
-					}// if(tri_al.Child.size())
-
-					// create new face and store it.
-					complex_face.Face.mNumIndices = 3;
-					complex_face.Face.mIndices = new unsigned int[3];
-					complex_face.Face.mIndices[0] = static_cast<unsigned int>(tri_al.V[0]);
-					complex_face.Face.mIndices[1] = static_cast<unsigned int>(tri_al.V[1]);
-					complex_face.Face.mIndices[2] = static_cast<unsigned int>(tri_al.V[2]);
-					complex_faces_list.push_back(complex_face);
-				}
-			}// for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
-
-			/**** Split faces list: one list per mesh ****/
-			PostprocessHelper_SplitFacesByTextureID(complex_faces_list, complex_faces_toplist);
-
-			/***** Create mesh for every faces list ******/
-			for(std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
-			{
-				auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
-				{
-					size_t rv=0;
-
-					if(pBiggerThan != nullptr)
-					{
-						bool found = false;
-
-						for(const SComplexFace& face: pFaceList)
-						{
-							for(size_t idx_vert = 0; idx_vert < face.Face.mNumIndices; idx_vert++)
-							{
-								if(face.Face.mIndices[idx_vert] > *pBiggerThan)
-								{
-									rv = face.Face.mIndices[idx_vert];
-									found = true;
-
-									break;
-								}
-							}
-
-							if(found) break;
-						}
-
-						if(!found) return *pBiggerThan;
-					}
-					else
-					{
-						rv = pFaceList.front().Face.mIndices[0];
-					}// if(pBiggerThan != nullptr) else
-
-					for(const SComplexFace& face: pFaceList)
-					{
-						for(size_t vi = 0; vi < face.Face.mNumIndices; vi++)
-						{
-							if(face.Face.mIndices[vi] < rv)
-							{
-								if(pBiggerThan != nullptr)
-								{
-									if(face.Face.mIndices[vi] > *pBiggerThan) rv = face.Face.mIndices[vi];
-								}
-								else
-								{
-									rv = face.Face.mIndices[vi];
-								}
-							}
-						}
-					}// for(const SComplexFace& face: pFaceList)
-
-					return rv;
-				};// auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
-
-				auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
-				{
-					for(const SComplexFace& face: pFaceList)
-					{
-						for(size_t vi = 0; vi < face.Face.mNumIndices; vi++)
-						{
-							if(face.Face.mIndices[vi] == pIdx_From) face.Face.mIndices[vi] = static_cast<unsigned int>(pIdx_To);
-						}
-					}
-				};// auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
-
-				auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D
-				{
-					// Color priorities(In descending order):
-					// 1. triangle color;
-					// 2. vertex color;
-					// 3. volume color;
-					// 4. object color;
-					// 5. material;
-					// 6. default - invisible coat.
-					//
-					// Fill vertices colors in color priority list above that's points from 1 to 6.
-					if((pIdx < pVertexColorArray.size()) && (pVertexColorArray[pIdx] != nullptr))// check for vertex color
-					{
-						if(pVertexColorArray[pIdx]->Composed)
-							throw DeadlyImportError("IME: vertex color composed");
-						else
-							return pVertexColorArray[pIdx]->Color;
-					}
-					else if(ne_volume_color != nullptr)// check for volume color
-					{
-						if(ne_volume_color->Composed)
-							throw DeadlyImportError("IME: volume color composed");
-						else
-							return ne_volume_color->Color;
-					}
-					else if(pObjectColor != nullptr)// check for object color
-					{
-						if(pObjectColor->Composed)
-							throw DeadlyImportError("IME: object color composed");
-						else
-							return pObjectColor->Color;
-					}
-					else if(cur_mat != nullptr)// check for material
-					{
-						return cur_mat->GetColor(pVertexCoordinateArray.at(pIdx).x, pVertexCoordinateArray.at(pIdx).y, pVertexCoordinateArray.at(pIdx).z);
-					}
-					else// set default color.
-					{
-						return {0, 0, 0, 0};
-					}// if((vi < pVertexColorArray.size()) && (pVertexColorArray[vi] != nullptr)) else
-
-				};// auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D
-
-				aiMesh* tmesh = new aiMesh;
-
-				tmesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;// Only triangles is supported by AMF.
-				//
-				// set geometry and colors (vertices)
-				//
-				// copy faces/triangles
-				tmesh->mNumFaces = static_cast<unsigned int>(face_list_cur.size());
-				tmesh->mFaces = new aiFace[tmesh->mNumFaces];
-
-				// Create vertices list and optimize indices. Optimisation mean following.In AMF all volumes use one big list of vertices. And one volume
-				// can use only part of vertices list, for example: vertices list contain few thousands of vertices and volume use vertices 1, 3, 10.
-				// Do you need all this thousands of garbage? Of course no. So, optimisation step transformate sparse indices set to continuous.
-				size_t VertexCount_Max = tmesh->mNumFaces * 3;// 3 - triangles.
-				std::vector<aiVector3D> vert_arr, texcoord_arr;
-				std::vector<aiColor4D> col_arr;
-
-				vert_arr.reserve(VertexCount_Max * 2);// "* 2" - see below TODO.
-				col_arr.reserve(VertexCount_Max * 2);
-
-				{// fill arrays
-					size_t vert_idx_from, vert_idx_to;
-
-					// first iteration.
-					vert_idx_to = 0;
-					vert_idx_from = VertexIndex_GetMinimal(face_list_cur, nullptr);
-					vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
-					col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
-					if(vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
-
-					// rest iterations
-					do
-					{
-						vert_idx_from = VertexIndex_GetMinimal(face_list_cur, &vert_idx_to);
-						if(vert_idx_from == vert_idx_to) break;// all indices are transferred,
-
-						vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
-						col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
-						vert_idx_to++;
-						if(vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
-
-					} while(true);
-				}// fill arrays. END.
-
-				//
-				// check if triangle colors are used and create additional faces if needed.
-				//
-				for(const SComplexFace& face_cur: face_list_cur)
-				{
-					if(face_cur.Color != nullptr)
-					{
-						aiColor4D face_color;
-						size_t vert_idx_new = vert_arr.size();
-
-						if(face_cur.Color->Composed)
-							throw DeadlyImportError("IME: face color composed");
-						else
-							face_color = face_cur.Color->Color;
-
-						for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
-						{
-							vert_arr.push_back(vert_arr.at(face_cur.Face.mIndices[idx_ind]));
-							col_arr.push_back(face_color);
-							face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(vert_idx_new++);
-						}
-					}// if(face_cur.Color != nullptr)
-				}// for(const SComplexFace& face_cur: face_list_cur)
-
-				//
-				// if texture is used then copy texture coordinates too.
-				//
-				if(face_list_cur.front().TexMap != nullptr)
-				{
-					size_t idx_vert_new = vert_arr.size();
-					///TODO: clean unused vertices. "* 2": in certain cases - mesh full of triangle colors - vert_arr will contain duplicated vertices for
-					/// colored triangles and initial vertices (for colored vertices) which in real became unused. This part need more thinking about
-					/// optimisation.
-					bool* idx_vert_used;
-
-					idx_vert_used = new bool[VertexCount_Max * 2];
-					for(size_t i = 0, i_e = VertexCount_Max * 2; i < i_e; i++) idx_vert_used[i] = false;
-
-					// This ID's will be used when set materials ID in scene.
-					tmesh->mMaterialIndex = static_cast<unsigned int>(PostprocessHelper_GetTextureID_Or_Create(face_list_cur.front().TexMap->TextureID_R,
-																						face_list_cur.front().TexMap->TextureID_G,
-																						face_list_cur.front().TexMap->TextureID_B,
-																						face_list_cur.front().TexMap->TextureID_A));
-					texcoord_arr.resize(VertexCount_Max * 2);
-					for(const SComplexFace& face_cur: face_list_cur)
-					{
-						for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
-						{
-							const size_t idx_vert = face_cur.Face.mIndices[idx_ind];
-
-							if(!idx_vert_used[idx_vert])
-							{
-								texcoord_arr.at(idx_vert) = face_cur.TexMap->TextureCoordinate[idx_ind];
-								idx_vert_used[idx_vert] = true;
-							}
-							else if(texcoord_arr.at(idx_vert) != face_cur.TexMap->TextureCoordinate[idx_ind])
-							{
-								// in that case one vertex is shared with many texture coordinates. We need to duplicate vertex with another texture
-								// coordinates.
-								vert_arr.push_back(vert_arr.at(idx_vert));
-								col_arr.push_back(col_arr.at(idx_vert));
-								texcoord_arr.at(idx_vert_new) = face_cur.TexMap->TextureCoordinate[idx_ind];
-								face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(idx_vert_new++);
-							}
-						}// for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
-					}// for(const SComplexFace& face_cur: face_list_cur)
-
-					delete [] idx_vert_used;
-					// shrink array
-					texcoord_arr.resize(idx_vert_new);
-				}// if(face_list_cur.front().TexMap != nullptr)
-
-				//
-				// copy collected data to mesh
-				//
-				tmesh->mNumVertices = static_cast<unsigned int>(vert_arr.size());
-				tmesh->mVertices = new aiVector3D[tmesh->mNumVertices];
-				tmesh->mColors[0] = new aiColor4D[tmesh->mNumVertices];
-
-				memcpy(tmesh->mVertices, vert_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
-				memcpy(tmesh->mColors[0], col_arr.data(), tmesh->mNumVertices * sizeof(aiColor4D));
-				if(texcoord_arr.size() > 0)
-				{
-					tmesh->mTextureCoords[0] = new aiVector3D[tmesh->mNumVertices];
-					memcpy(tmesh->mTextureCoords[0], texcoord_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
-					tmesh->mNumUVComponents[0] = 2;// U and V stored in "x", "y" of aiVector3D.
-				}
-
-				size_t idx_face = 0;
-				for(const SComplexFace& face_cur: face_list_cur) tmesh->mFaces[idx_face++] = face_cur.Face;
-
-				// store new aiMesh
-				mesh_idx.push_back(static_cast<unsigned int>(pMeshList.size()));
-				pMeshList.push_back(tmesh);
-			}// for(const std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
-		}// if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
-	}// for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
-
-	// if meshes was created then assign new indices with current aiNode
-	if(!mesh_idx.empty())
-	{
-		std::list<unsigned int>::const_iterator mit = mesh_idx.begin();
-
-		pSceneNode.mNumMeshes = static_cast<unsigned int>(mesh_idx.size());
-		pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
-		for(size_t i = 0; i < pSceneNode.mNumMeshes; i++) pSceneNode.mMeshes[i] = *mit++;
-	}// if(mesh_idx.size() > 0)
-}
-
-void AMFImporter::Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material& pMaterial)
-{
-SPP_Material new_mat;
-
-	new_mat.ID = pMaterial.ID;
-	for(const CAMFImporter_NodeElement* mat_child: pMaterial.Child)
-	{
-		if(mat_child->Type == CAMFImporter_NodeElement::ENET_Color)
-		{
-			new_mat.Color = (CAMFImporter_NodeElement_Color*)mat_child;
-		}
-		else if(mat_child->Type == CAMFImporter_NodeElement::ENET_Metadata)
-		{
-			new_mat.Metadata.push_back((CAMFImporter_NodeElement_Metadata*)mat_child);
-		}
-	}// for(const CAMFImporter_NodeElement* mat_child; pMaterial.Child)
-
-	// place converted material to special list
-	mMaterial_Converted.push_back(new_mat);
-}
-
-void AMFImporter::Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation& pConstellation, std::list<aiNode*>& pNodeList) const
-{
-aiNode* con_node;
-std::list<aiNode*> ch_node;
-
-	// We will build next hierarchy:
-	// aiNode as parent (<constellation>) for set of nodes as a children
-	//  |- aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
-	//  ...
-	//  \_ aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
-	con_node = new aiNode;
-	con_node->mName = pConstellation.ID;
-	// Walk through children and search for instances of another objects, constellations.
-	for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
-	{
-		aiMatrix4x4 tmat;
-		aiNode* t_node;
-		aiNode* found_node;
-
-		if(ne->Type == CAMFImporter_NodeElement::ENET_Metadata) continue;
-		if(ne->Type != CAMFImporter_NodeElement::ENET_Instance) throw DeadlyImportError("Only <instance> nodes can be in <constellation>.");
-
-		// create alias for conveniance
-		CAMFImporter_NodeElement_Instance& als = *((CAMFImporter_NodeElement_Instance*)ne);
-		// find referenced object
-		if(!Find_ConvertedNode(als.ObjectID, pNodeList, &found_node)) Throw_ID_NotFound(als.ObjectID);
-
-		// create node for applying transformation
-		t_node = new aiNode;
-		t_node->mParent = con_node;
-		// apply transformation
-		aiMatrix4x4::Translation(als.Delta, tmat), t_node->mTransformation *= tmat;
-		aiMatrix4x4::RotationX(als.Rotation.x, tmat), t_node->mTransformation *= tmat;
-		aiMatrix4x4::RotationY(als.Rotation.y, tmat), t_node->mTransformation *= tmat;
-		aiMatrix4x4::RotationZ(als.Rotation.z, tmat), t_node->mTransformation *= tmat;
-		// create array for one child node
-		t_node->mNumChildren = 1;
-		t_node->mChildren = new aiNode*[t_node->mNumChildren];
-		SceneCombiner::Copy(&t_node->mChildren[0], found_node);
-		t_node->mChildren[0]->mParent = t_node;
-		ch_node.push_back(t_node);
-	}// for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
-
-	// copy found aiNode's as children
-	if(ch_node.empty()) throw DeadlyImportError("<constellation> must have at least one <instance>.");
-
-	size_t ch_idx = 0;
-
-	con_node->mNumChildren = static_cast<unsigned int>(ch_node.size());
-	con_node->mChildren = new aiNode*[con_node->mNumChildren];
-	for(aiNode* node: ch_node) con_node->mChildren[ch_idx++] = node;
-
-	// and place "root" of <constellation> node to node list
-	pNodeList.push_back(con_node);
-}
-
-void AMFImporter::Postprocess_BuildScene(aiScene* pScene)
-{
-std::list<aiNode*> node_list;
-std::list<aiMesh*> mesh_list;
-std::list<CAMFImporter_NodeElement_Metadata*> meta_list;
-
-	//
-	// Because for AMF "material" is just complex colors mixing so aiMaterial will not be used.
-	// For building aiScene we are must to do few steps:
-	// at first creating root node for aiScene.
-	pScene->mRootNode = new aiNode;
-	pScene->mRootNode->mParent = nullptr;
-	pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
-	// search for root(<amf>) element
-	CAMFImporter_NodeElement* root_el = nullptr;
-
-	for(CAMFImporter_NodeElement* ne: mNodeElement_List)
-	{
-		if(ne->Type != CAMFImporter_NodeElement::ENET_Root) continue;
-
-		root_el = ne;
-
-		break;
-	}// for(const CAMFImporter_NodeElement* ne: mNodeElement_List)
-
-	// Check if root element are found.
-	if(root_el == nullptr) throw DeadlyImportError("Root(<amf>) element not found.");
-
-	// after that walk through children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
-	// <constellation> and <metadata>. But at first we must read <material> and <texture> because they will be used in <object>. <metadata> can be read
-	// at any moment.
-	//
-	// 1. <material>
-	// 2. <texture> will be converted later when processing triangles list. \sa Postprocess_BuildMeshSet
-	for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-	{
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Material) Postprocess_BuildMaterial(*((CAMFImporter_NodeElement_Material*)root_child));
-	}
-
-	// After "appearance" nodes we must read <object> because it will be used in <constellation> -> <instance>.
-	//
-	// 3. <object>
-	for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-	{
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Object)
-		{
-			aiNode* tnode = nullptr;
-
-			// for <object> mesh and node must be built: object ID assigned to aiNode name and will be used in future for <instance>
-			Postprocess_BuildNodeAndObject(*((CAMFImporter_NodeElement_Object*)root_child), mesh_list, &tnode);
-			if(tnode != nullptr) node_list.push_back(tnode);
-
-		}
-	}// for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-
-	// And finally read rest of nodes.
-	//
-	for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-	{
-		// 4. <constellation>
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Constellation)
-		{
-			// <object> and <constellation> at top of self abstraction use aiNode. So we can use only aiNode list for creating new aiNode's.
-			Postprocess_BuildConstellation(*((CAMFImporter_NodeElement_Constellation*)root_child), node_list);
-		}
-
-		// 5, <metadata>
-		if(root_child->Type == CAMFImporter_NodeElement::ENET_Metadata) meta_list.push_back((CAMFImporter_NodeElement_Metadata*)root_child);
-	}// for(const CAMFImporter_NodeElement* root_child: root_el->Child)
-
-	// at now we can add collected metadata to root node
-	Postprocess_AddMetadata(meta_list, *pScene->mRootNode);
-	//
-	// Check constellation children
-	//
-	// As said in specification:
-	// "When multiple objects and constellations are defined in a single file, only the top level objects and constellations are available for printing."
-	// What that means? For example: if some object is used in constellation then you must show only constellation but not original object.
-	// And at this step we are checking that relations.
-nl_clean_loop:
-
-	if(node_list.size() > 1)
-	{
-		// walk through all nodes
-		for(std::list<aiNode*>::iterator nl_it = node_list.begin(); nl_it != node_list.end(); ++nl_it)
-		{
-			// and try to find them in another top nodes.
-			std::list<aiNode*>::const_iterator next_it = nl_it;
-
-			++next_it;
-			for(; next_it != node_list.end(); ++next_it)
-			{
-				if((*next_it)->FindNode((*nl_it)->mName) != nullptr)
-				{
-					// if current top node(nl_it) found in another top node then erase it from node_list and restart search loop.
-					node_list.erase(nl_it);
-
-					goto nl_clean_loop;
-				}
-			}// for(; next_it != node_list.end(); next_it++)
-		}// for(std::list<aiNode*>::const_iterator nl_it = node_list.begin(); nl_it != node_list.end(); nl_it++)
-	}
-
-	//
-	// move created objects to aiScene
-	//
-	//
-	// Nodes
-	if(!node_list.empty())
-	{
-		std::list<aiNode*>::const_iterator nl_it = node_list.begin();
-
-		pScene->mRootNode->mNumChildren = static_cast<unsigned int>(node_list.size());
-		pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
-		for(size_t i = 0; i < pScene->mRootNode->mNumChildren; i++)
-		{
-			// Objects and constellation that must be showed placed at top of hierarchy in <amf> node. So all aiNode's in node_list must have
-			// mRootNode only as parent.
-			(*nl_it)->mParent = pScene->mRootNode;
-			pScene->mRootNode->mChildren[i] = *nl_it++;
-		}
-	}// if(node_list.size() > 0)
-
-	//
-	// Meshes
-	if(!mesh_list.empty())
-	{
-		std::list<aiMesh*>::const_iterator ml_it = mesh_list.begin();
-
-		pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
-		pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-		for(size_t i = 0; i < pScene->mNumMeshes; i++) pScene->mMeshes[i] = *ml_it++;
-	}// if(mesh_list.size() > 0)
-
-	//
-	// Textures
-	pScene->mNumTextures = static_cast<unsigned int>(mTexture_Converted.size());
-	if(pScene->mNumTextures > 0)
-	{
-		size_t idx;
-
-		idx = 0;
-		pScene->mTextures = new aiTexture*[pScene->mNumTextures];
-		for(const SPP_Texture& tex_convd: mTexture_Converted)
-		{
-			pScene->mTextures[idx] = new aiTexture;
-			pScene->mTextures[idx]->mWidth = static_cast<unsigned int>(tex_convd.Width);
-			pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
-			pScene->mTextures[idx]->pcData = (aiTexel*)tex_convd.Data;
-			// texture format description.
-			strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
-			idx++;
-		}// for(const SPP_Texture& tex_convd: mTexture_Converted)
-
-		// Create materials for embedded textures.
-		idx = 0;
-		pScene->mNumMaterials = static_cast<unsigned int>(mTexture_Converted.size());
-		pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
-		for(const SPP_Texture& tex_convd: mTexture_Converted)
-		{
-			const aiString texture_id(AI_EMBEDDED_TEXNAME_PREFIX + to_string(idx));
-			const int mode = aiTextureOp_Multiply;
-			const int repeat = tex_convd.Tiled ? 1 : 0;
-
-			pScene->mMaterials[idx] = new aiMaterial;
-			pScene->mMaterials[idx]->AddProperty(&texture_id, AI_MATKEY_TEXTURE_DIFFUSE(0));
-			pScene->mMaterials[idx]->AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
-			pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
-			pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
-			idx++;
-		}
-	}// if(pScene->mNumTextures > 0)
-}// END: after that walk through children of root and collect data
-
-}// namespace Assimp
-
-#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/code/3DS/3DSConverter.cpp b/code/AssetLib/3DS/3DSConverter.cpp
similarity index 59%
rename from code/3DS/3DSConverter.cpp
rename to code/AssetLib/3DS/3DSConverter.cpp
index 8c8a8200a..1004c74a5 100644
--- a/code/3DS/3DSConverter.cpp
+++ b/code/AssetLib/3DS/3DSConverter.cpp
@@ -46,11 +46,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "3DSLoader.h"
 #include "Common/TargetAnimation.h"
+#include <assimp/StringComparison.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/StringComparison.h>
-#include <memory>
 #include <cctype>
+#include <memory>
 
 using namespace Assimp;
 
@@ -58,75 +58,66 @@ static const unsigned int NotSet = 0xcdcdcdcd;
 
 // ------------------------------------------------------------------------------------------------
 // Setup final material indices, generae a default material if necessary
-void Discreet3DSImporter::ReplaceDefaultMaterial()
-{
+void Discreet3DSImporter::ReplaceDefaultMaterial() {
     // Try to find an existing material that matches the
     // typical default material setting:
     // - no textures
     // - diffuse color (in grey!)
     // NOTE: This is here to workaround the fact that some
     // exporters are writing a default material, too.
-    unsigned int idx( NotSet );
-    for (unsigned int i = 0; i < mScene->mMaterials.size();++i)
-    {
+    unsigned int idx(NotSet);
+    for (unsigned int i = 0; i < mScene->mMaterials.size(); ++i) {
         std::string s = mScene->mMaterials[i].mName;
-        for ( std::string::iterator it = s.begin(); it != s.end(); ++it ) {
-            *it = static_cast< char >( ::tolower( *it ) );
+        for (std::string::iterator it = s.begin(); it != s.end(); ++it) {
+            *it = static_cast<char>(::tolower(*it));
         }
 
-        if (std::string::npos == s.find("default"))continue;
+        if (std::string::npos == s.find("default")) continue;
 
         if (mScene->mMaterials[i].mDiffuse.r !=
-            mScene->mMaterials[i].mDiffuse.g ||
-            mScene->mMaterials[i].mDiffuse.r !=
-            mScene->mMaterials[i].mDiffuse.b)continue;
+                        mScene->mMaterials[i].mDiffuse.g ||
+                mScene->mMaterials[i].mDiffuse.r !=
+                        mScene->mMaterials[i].mDiffuse.b) continue;
 
-        if (mScene->mMaterials[i].sTexDiffuse.mMapName.length()   != 0  ||
-            mScene->mMaterials[i].sTexBump.mMapName.length()      != 0  ||
-            mScene->mMaterials[i].sTexOpacity.mMapName.length()   != 0  ||
-            mScene->mMaterials[i].sTexEmissive.mMapName.length()  != 0  ||
-            mScene->mMaterials[i].sTexSpecular.mMapName.length()  != 0  ||
-            mScene->mMaterials[i].sTexShininess.mMapName.length() != 0 )
-        {
+        if (mScene->mMaterials[i].sTexDiffuse.mMapName.length() != 0 ||
+                mScene->mMaterials[i].sTexBump.mMapName.length() != 0 ||
+                mScene->mMaterials[i].sTexOpacity.mMapName.length() != 0 ||
+                mScene->mMaterials[i].sTexEmissive.mMapName.length() != 0 ||
+                mScene->mMaterials[i].sTexSpecular.mMapName.length() != 0 ||
+                mScene->mMaterials[i].sTexShininess.mMapName.length() != 0) {
             continue;
         }
         idx = i;
     }
-    if ( NotSet == idx ) {
-        idx = ( unsigned int )mScene->mMaterials.size();
+    if (NotSet == idx) {
+        idx = (unsigned int)mScene->mMaterials.size();
     }
 
     // now iterate through all meshes and through all faces and
     // find all faces that are using the default material
     unsigned int cnt = 0;
     for (std::vector<D3DS::Mesh>::iterator
-        i =  mScene->mMeshes.begin();
-        i != mScene->mMeshes.end();++i)
-    {
+                    i = mScene->mMeshes.begin();
+            i != mScene->mMeshes.end(); ++i) {
         for (std::vector<unsigned int>::iterator
-            a =  (*i).mFaceMaterials.begin();
-            a != (*i).mFaceMaterials.end();++a)
-        {
+                        a = (*i).mFaceMaterials.begin();
+                a != (*i).mFaceMaterials.end(); ++a) {
             // NOTE: The additional check seems to be necessary,
             // some exporters seem to generate invalid data here
-            if (0xcdcdcdcd == (*a))
-            {
+            if (0xcdcdcdcd == (*a)) {
                 (*a) = idx;
                 ++cnt;
-            }
-            else if ( (*a) >= mScene->mMaterials.size())
-            {
+            } else if ((*a) >= mScene->mMaterials.size()) {
                 (*a) = idx;
                 ASSIMP_LOG_WARN("Material index overflow in 3DS file. Using default material");
                 ++cnt;
             }
         }
     }
-    if (cnt && idx == mScene->mMaterials.size())
-    {
+    if (cnt && idx == mScene->mMaterials.size()) {
         // We need to create our own default material
         D3DS::Material sMat("%%%DEFAULT");
-        sMat.mDiffuse = aiColor3D(0.3f,0.3f,0.3f);
+        sMat.mDiffuse = aiColor3D(0.3f, 0.3f, 0.3f);
         mScene->mMaterials.push_back(sMat);
 
         ASSIMP_LOG_INFO("3DS: Generating default material");
@@ -135,22 +126,17 @@ void Discreet3DSImporter::ReplaceDefaultMaterial()
 
 // ------------------------------------------------------------------------------------------------
 // Check whether all indices are valid. Otherwise we'd crash before the validation step is reached
-void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
-{
-    for (std::vector< D3DS::Face >::iterator i =  sMesh.mFaces.begin(); i != sMesh.mFaces.end();++i)
-    {
+void Discreet3DSImporter::CheckIndices(D3DS::Mesh &sMesh) {
+    for (std::vector<D3DS::Face>::iterator i = sMesh.mFaces.begin(); i != sMesh.mFaces.end(); ++i) {
         // check whether all indices are in range
-        for (unsigned int a = 0; a < 3;++a)
-        {
-            if ((*i).mIndices[a] >= sMesh.mPositions.size())
-            {
+        for (unsigned int a = 0; a < 3; ++a) {
+            if ((*i).mIndices[a] >= sMesh.mPositions.size()) {
                 ASSIMP_LOG_WARN("3DS: Vertex index overflow)");
-                (*i).mIndices[a] = (uint32_t)sMesh.mPositions.size()-1;
+                (*i).mIndices[a] = (uint32_t)sMesh.mPositions.size() - 1;
             }
-            if ( !sMesh.mTexCoords.empty() && (*i).mIndices[a] >= sMesh.mTexCoords.size())
-            {
+            if (!sMesh.mTexCoords.empty() && (*i).mIndices[a] >= sMesh.mTexCoords.size()) {
                 ASSIMP_LOG_WARN("3DS: Texture coordinate index overflow)");
-                (*i).mIndices[a] = (uint32_t)sMesh.mTexCoords.size()-1;
+                (*i).mIndices[a] = (uint32_t)sMesh.mTexCoords.size() - 1;
             }
         }
     }
@@ -158,24 +144,21 @@ void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
 
 // ------------------------------------------------------------------------------------------------
 // Generate out unique verbose format representation
-void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
-{
+void Discreet3DSImporter::MakeUnique(D3DS::Mesh &sMesh) {
     // TODO: really necessary? I don't think. Just a waste of memory and time
     // to do it now in a separate buffer.
 
     // Allocate output storage
-    std::vector<aiVector3D> vNew  (sMesh.mFaces.size() * 3);
+    std::vector<aiVector3D> vNew(sMesh.mFaces.size() * 3);
     std::vector<aiVector3D> vNew2;
     if (sMesh.mTexCoords.size())
         vNew2.resize(sMesh.mFaces.size() * 3);
 
-    for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size();++i)
-    {
-        D3DS::Face& face = sMesh.mFaces[i];
+    for (unsigned int i = 0, base = 0; i < sMesh.mFaces.size(); ++i) {
+        D3DS::Face &face = sMesh.mFaces[i];
 
         // Positions
-        for (unsigned int a = 0; a < 3;++a,++base)
-        {
+        for (unsigned int a = 0; a < 3; ++a, ++base) {
             vNew[base] = sMesh.mPositions[face.mIndices[a]];
             if (sMesh.mTexCoords.size())
                 vNew2[base] = sMesh.mTexCoords[face.mIndices[a]];
@@ -189,26 +172,24 @@ void Discreet3DSImporter::MakeUnique(D3DS::Mesh& sMesh)
 
 // ------------------------------------------------------------------------------------------------
 // Convert a 3DS texture to texture keys in an aiMaterial
-void CopyTexture(aiMaterial& mat, D3DS::Texture& texture, aiTextureType type)
-{
+void CopyTexture(aiMaterial &mat, D3DS::Texture &texture, aiTextureType type) {
     // Setup the texture name
     aiString tex;
-    tex.Set( texture.mMapName);
-    mat.AddProperty( &tex, AI_MATKEY_TEXTURE(type,0));
+    tex.Set(texture.mMapName);
+    mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));
 
     // Setup the texture blend factor
     if (is_not_qnan(texture.mTextureBlend))
-        mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0));
+        mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));
 
     // Setup the texture mapping mode
     int mapMode = static_cast<int>(texture.mMapMode);
-    mat.AddProperty<int>(&mapMode,1,AI_MATKEY_MAPPINGMODE_U(type,0));
-    mat.AddProperty<int>(&mapMode,1,AI_MATKEY_MAPPINGMODE_V(type,0));
+    mat.AddProperty<int>(&mapMode, 1, AI_MATKEY_MAPPINGMODE_U(type, 0));
+    mat.AddProperty<int>(&mapMode, 1, AI_MATKEY_MAPPINGMODE_V(type, 0));
 
     // Mirroring - double the scaling values
     // FIXME: this is not really correct ...
-    if (texture.mMapMode == aiTextureMapMode_Mirror)
-    {
+    if (texture.mMapMode == aiTextureMapMode_Mirror) {
         texture.mScaleU *= 2.0;
         texture.mScaleV *= 2.0;
         texture.mOffsetU /= 2.0;
@@ -216,21 +197,19 @@ void CopyTexture(aiMaterial& mat, D3DS::Texture& texture, aiTextureType type)
     }
 
     // Setup texture UV transformations
-    mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0));
+    mat.AddProperty<ai_real>(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert a 3DS material to an aiMaterial
-void Discreet3DSImporter::ConvertMaterial(D3DS::Material& oldMat,
-    aiMaterial& mat)
-{
+void Discreet3DSImporter::ConvertMaterial(D3DS::Material &oldMat,
+        aiMaterial &mat) {
     // NOTE: Pass the background image to the viewer by bypassing the
     // material system. This is an evil hack, never do it again!
-    if (0 != mBackgroundImage.length() && bHasBG)
-    {
+    if (0 != mBackgroundImage.length() && bHasBG) {
         aiString tex;
-        tex.Set( mBackgroundImage);
-        mat.AddProperty( &tex, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE);
+        tex.Set(mBackgroundImage);
+        mat.AddProperty(&tex, AI_MATKEY_GLOBAL_BACKGROUND_IMAGE);
 
         // Be sure this is only done for the first material
         mBackgroundImage = std::string("");
@@ -242,143 +221,138 @@ void Discreet3DSImporter::ConvertMaterial(D3DS::Material& oldMat,
     oldMat.mAmbient.b += mClrAmbient.b;
 
     aiString name;
-    name.Set( oldMat.mName);
-    mat.AddProperty( &name, AI_MATKEY_NAME);
+    name.Set(oldMat.mName);
+    mat.AddProperty(&name, AI_MATKEY_NAME);
 
     // Material colors
-    mat.AddProperty( &oldMat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
-    mat.AddProperty( &oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-    mat.AddProperty( &oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
-    mat.AddProperty( &oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+    mat.AddProperty(&oldMat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
+    mat.AddProperty(&oldMat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mat.AddProperty(&oldMat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
+    mat.AddProperty(&oldMat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
 
     // Phong shininess and shininess strength
     if (D3DS::Discreet3DS::Phong == oldMat.mShading ||
-        D3DS::Discreet3DS::Metal == oldMat.mShading)
-    {
-        if (!oldMat.mSpecularExponent || !oldMat.mShininessStrength)
-        {
+            D3DS::Discreet3DS::Metal == oldMat.mShading) {
+        if (!oldMat.mSpecularExponent || !oldMat.mShininessStrength) {
             oldMat.mShading = D3DS::Discreet3DS::Gouraud;
-        }
-        else
-        {
-            mat.AddProperty( &oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
-            mat.AddProperty( &oldMat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
+        } else {
+            mat.AddProperty(&oldMat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
+            mat.AddProperty(&oldMat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
         }
     }
 
     // Opacity
-    mat.AddProperty<ai_real>( &oldMat.mTransparency,1,AI_MATKEY_OPACITY);
+    mat.AddProperty<ai_real>(&oldMat.mTransparency, 1, AI_MATKEY_OPACITY);
 
     // Bump height scaling
-    mat.AddProperty<ai_real>( &oldMat.mBumpHeight,1,AI_MATKEY_BUMPSCALING);
+    mat.AddProperty<ai_real>(&oldMat.mBumpHeight, 1, AI_MATKEY_BUMPSCALING);
 
     // Two sided rendering?
-    if (oldMat.mTwoSided)
-    {
+    if (oldMat.mTwoSided) {
         int i = 1;
-        mat.AddProperty<int>(&i,1,AI_MATKEY_TWOSIDED);
+        mat.AddProperty<int>(&i, 1, AI_MATKEY_TWOSIDED);
     }
 
     // Shading mode
     aiShadingMode eShading = aiShadingMode_NoShading;
-    switch (oldMat.mShading)
-    {
-        case D3DS::Discreet3DS::Flat:
-            eShading = aiShadingMode_Flat; break;
+    switch (oldMat.mShading) {
+    case D3DS::Discreet3DS::Flat:
+        eShading = aiShadingMode_Flat;
+        break;
 
-        // I don't know what "Wire" shading should be,
-        // assume it is simple lambertian diffuse shading
-        case D3DS::Discreet3DS::Wire:
-            {
-                // Set the wireframe flag
-                unsigned int iWire = 1;
-                mat.AddProperty<int>( (int*)&iWire,1,AI_MATKEY_ENABLE_WIREFRAME);
-            }
+    // I don't know what "Wire" shading should be,
+    // assume it is simple lambertian diffuse shading
+    case D3DS::Discreet3DS::Wire: {
+        // Set the wireframe flag
+        unsigned int iWire = 1;
+        mat.AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);
+    }
 
-        case D3DS::Discreet3DS::Gouraud:
-            eShading = aiShadingMode_Gouraud; break;
+    case D3DS::Discreet3DS::Gouraud:
+        eShading = aiShadingMode_Gouraud;
+        break;
 
-        // assume cook-torrance shading for metals.
-        case D3DS::Discreet3DS::Phong :
-            eShading = aiShadingMode_Phong; break;
+    // assume cook-torrance shading for metals.
+    case D3DS::Discreet3DS::Phong:
+        eShading = aiShadingMode_Phong;
+        break;
 
-        case D3DS::Discreet3DS::Metal :
-            eShading = aiShadingMode_CookTorrance; break;
+    case D3DS::Discreet3DS::Metal:
+        eShading = aiShadingMode_CookTorrance;
+        break;
 
-            // FIX to workaround a warning with GCC 4 who complained
-            // about a missing case Blinn: here - Blinn isn't a valid
-            // value in the 3DS Loader, it is just needed for ASE
-        case D3DS::Discreet3DS::Blinn :
-            eShading = aiShadingMode_Blinn; break;
+        // FIX to workaround a warning with GCC 4 who complained
+        // about a missing case Blinn: here - Blinn isn't a valid
+        // value in the 3DS Loader, it is just needed for ASE
+    case D3DS::Discreet3DS::Blinn:
+        eShading = aiShadingMode_Blinn;
+        break;
     }
     int eShading_ = static_cast<int>(eShading);
     mat.AddProperty<int>(&eShading_, 1, AI_MATKEY_SHADING_MODEL);
 
     // DIFFUSE texture
-    if( oldMat.sTexDiffuse.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexDiffuse, aiTextureType_DIFFUSE);
+    if (oldMat.sTexDiffuse.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexDiffuse, aiTextureType_DIFFUSE);
 
     // SPECULAR texture
-    if( oldMat.sTexSpecular.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexSpecular, aiTextureType_SPECULAR);
+    if (oldMat.sTexSpecular.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexSpecular, aiTextureType_SPECULAR);
 
     // OPACITY texture
-    if( oldMat.sTexOpacity.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexOpacity, aiTextureType_OPACITY);
+    if (oldMat.sTexOpacity.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexOpacity, aiTextureType_OPACITY);
 
     // EMISSIVE texture
-    if( oldMat.sTexEmissive.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexEmissive, aiTextureType_EMISSIVE);
+    if (oldMat.sTexEmissive.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexEmissive, aiTextureType_EMISSIVE);
 
     // BUMP texture
-    if( oldMat.sTexBump.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexBump, aiTextureType_HEIGHT);
+    if (oldMat.sTexBump.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexBump, aiTextureType_HEIGHT);
 
     // SHININESS texture
-    if( oldMat.sTexShininess.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexShininess, aiTextureType_SHININESS);
+    if (oldMat.sTexShininess.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexShininess, aiTextureType_SHININESS);
 
     // REFLECTION texture
-    if( oldMat.sTexReflective.mMapName.length() > 0)
-        CopyTexture(mat,oldMat.sTexReflective, aiTextureType_REFLECTION);
+    if (oldMat.sTexReflective.mMapName.length() > 0)
+        CopyTexture(mat, oldMat.sTexReflective, aiTextureType_REFLECTION);
 
     // Store the name of the material itself, too
-    if( oldMat.mName.length())  {
+    if (oldMat.mName.length()) {
         aiString tex;
-        tex.Set( oldMat.mName);
-        mat.AddProperty( &tex, AI_MATKEY_NAME);
+        tex.Set(oldMat.mName);
+        mat.AddProperty(&tex, AI_MATKEY_NAME);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Split meshes by their materials and generate output aiMesh'es
-void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
-{
-    std::vector<aiMesh*> avOutMeshes;
+void Discreet3DSImporter::ConvertMeshes(aiScene *pcOut) {
+    std::vector<aiMesh *> avOutMeshes;
     avOutMeshes.reserve(mScene->mMeshes.size() * 2);
 
-    unsigned int iFaceCnt = 0,num = 0;
+    unsigned int iFaceCnt = 0, num = 0;
     aiString name;
 
     // we need to split all meshes by their materials
-    for (std::vector<D3DS::Mesh>::iterator i =  mScene->mMeshes.begin(); i != mScene->mMeshes.end();++i)    {
-        std::unique_ptr< std::vector<unsigned int>[] > aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
+    for (std::vector<D3DS::Mesh>::iterator i = mScene->mMeshes.begin(); i != mScene->mMeshes.end(); ++i) {
+        std::unique_ptr<std::vector<unsigned int>[]> aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
 
-        name.length = ASSIMP_itoa10(name.data,num++);
+        name.length = ASSIMP_itoa10(name.data, num++);
 
         unsigned int iNum = 0;
-        for (std::vector<unsigned int>::const_iterator a =  (*i).mFaceMaterials.begin();
-            a != (*i).mFaceMaterials.end();++a,++iNum)
-        {
+        for (std::vector<unsigned int>::const_iterator a = (*i).mFaceMaterials.begin();
+                a != (*i).mFaceMaterials.end(); ++a, ++iNum) {
             aiSplit[*a].push_back(iNum);
         }
         // now generate submeshes
-        for (unsigned int p = 0; p < mScene->mMaterials.size();++p)
-        {
+        for (unsigned int p = 0; p < mScene->mMaterials.size(); ++p) {
             if (aiSplit[p].empty()) {
                 continue;
             }
-            aiMesh* meshOut = new aiMesh();
+            aiMesh *meshOut = new aiMesh();
             meshOut->mName = name;
             meshOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
@@ -386,36 +360,33 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
             meshOut->mMaterialIndex = p;
 
             // use the color data as temporary storage
-            meshOut->mColors[0] = (aiColor4D*)(&*i);
+            meshOut->mColors[0] = (aiColor4D *)(&*i);
             avOutMeshes.push_back(meshOut);
 
             // convert vertices
             meshOut->mNumFaces = (unsigned int)aiSplit[p].size();
-            meshOut->mNumVertices = meshOut->mNumFaces*3;
+            meshOut->mNumVertices = meshOut->mNumFaces * 3;
 
             // allocate enough storage for faces
             meshOut->mFaces = new aiFace[meshOut->mNumFaces];
             iFaceCnt += meshOut->mNumFaces;
 
             meshOut->mVertices = new aiVector3D[meshOut->mNumVertices];
-            meshOut->mNormals  = new aiVector3D[meshOut->mNumVertices];
-            if ((*i).mTexCoords.size())
-            {
+            meshOut->mNormals = new aiVector3D[meshOut->mNumVertices];
+            if ((*i).mTexCoords.size()) {
                 meshOut->mTextureCoords[0] = new aiVector3D[meshOut->mNumVertices];
             }
-            for (unsigned int q = 0, base = 0; q < aiSplit[p].size();++q)
-            {
+            for (unsigned int q = 0, base = 0; q < aiSplit[p].size(); ++q) {
                 unsigned int index = aiSplit[p][q];
-                aiFace& face = meshOut->mFaces[q];
+                aiFace &face = meshOut->mFaces[q];
 
                 face.mIndices = new unsigned int[3];
                 face.mNumIndices = 3;
 
-                for (unsigned int a = 0; a < 3;++a,++base)
-                {
+                for (unsigned int a = 0; a < 3; ++a, ++base) {
                     unsigned int idx = (*i).mFaces[index].mIndices[a];
-                    meshOut->mVertices[base]  = (*i).mPositions[idx];
-                    meshOut->mNormals [base]  = (*i).mNormals[idx];
+                    meshOut->mVertices[base] = (*i).mPositions[idx];
+                    meshOut->mNormals[base] = (*i).mNormals[idx];
 
                     if ((*i).mTexCoords.size())
                         meshOut->mTextureCoords[0][base] = (*i).mTexCoords[idx];
@@ -428,8 +399,8 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
 
     // Copy them to the output array
     pcOut->mNumMeshes = (unsigned int)avOutMeshes.size();
-    pcOut->mMeshes = new aiMesh*[pcOut->mNumMeshes]();
-    for (unsigned int a = 0; a < pcOut->mNumMeshes;++a) {
+    pcOut->mMeshes = new aiMesh *[pcOut->mNumMeshes]();
+    for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a) {
         pcOut->mMeshes[a] = avOutMeshes[a];
     }
 
@@ -441,47 +412,44 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
 
 // ------------------------------------------------------------------------------------------------
 // Add a node to the scenegraph and setup its final transformation
-void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
-    D3DS::Node* pcIn, aiMatrix4x4& /*absTrafo*/)
-{
+void Discreet3DSImporter::AddNodeToGraph(aiScene *pcSOut, aiNode *pcOut,
+        D3DS::Node *pcIn, aiMatrix4x4 & /*absTrafo*/) {
     std::vector<unsigned int> iArray;
     iArray.reserve(3);
 
     aiMatrix4x4 abs;
 
     // Find all meshes with the same name as the node
-    for (unsigned int a = 0; a < pcSOut->mNumMeshes;++a)
-    {
-        const D3DS::Mesh* pcMesh = (const D3DS::Mesh*)pcSOut->mMeshes[a]->mColors[0];
-        ai_assert(NULL != pcMesh);
+    for (unsigned int a = 0; a < pcSOut->mNumMeshes; ++a) {
+        const D3DS::Mesh *pcMesh = (const D3DS::Mesh *)pcSOut->mMeshes[a]->mColors[0];
+        ai_assert(nullptr != pcMesh);
 
         if (pcIn->mName == pcMesh->mName)
             iArray.push_back(a);
     }
-    if (!iArray.empty())
-    {
+    if (!iArray.empty()) {
         // The matrix should be identical for all meshes with the
         // same name. It HAS to be identical for all meshes .....
-        D3DS::Mesh* imesh = ((D3DS::Mesh*)pcSOut->mMeshes[iArray[0]]->mColors[0]);
+        D3DS::Mesh *imesh = ((D3DS::Mesh *)pcSOut->mMeshes[iArray[0]]->mColors[0]);
 
         // Compute the inverse of the transformation matrix to move the
         // vertices back to their relative and local space
         aiMatrix4x4 mInv = imesh->mMat, mInvTransposed = imesh->mMat;
-        mInv.Inverse();mInvTransposed.Transpose();
+        mInv.Inverse();
+        mInvTransposed.Transpose();
         aiVector3D pivot = pcIn->vPivot;
 
         pcOut->mNumMeshes = (unsigned int)iArray.size();
         pcOut->mMeshes = new unsigned int[iArray.size()];
-        for (unsigned int i = 0;i < iArray.size();++i)  {
+        for (unsigned int i = 0; i < iArray.size(); ++i) {
             const unsigned int iIndex = iArray[i];
-            aiMesh* const mesh = pcSOut->mMeshes[iIndex];
+            aiMesh *const mesh = pcSOut->mMeshes[iIndex];
 
-            if (mesh->mColors[1] == NULL)
-            {
+            if (mesh->mColors[1] == nullptr) {
                 // Transform the vertices back into their local space
                 // fixme: consider computing normals after this, so we don't need to transform them
-                const aiVector3D* const pvEnd = mesh->mVertices + mesh->mNumVertices;
-                aiVector3D* pvCurrent = mesh->mVertices, *t2 = mesh->mNormals;
+                const aiVector3D *const pvEnd = mesh->mVertices + mesh->mNumVertices;
+                aiVector3D *pvCurrent = mesh->mVertices, *t2 = mesh->mNormals;
 
                 for (; pvCurrent != pvEnd; ++pvCurrent, ++t2) {
                     *pvCurrent = mInv * (*pvCurrent);
@@ -489,8 +457,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
                 }
 
                 // Handle negative transformation matrix determinant -> invert vertex x
-                if (imesh->mMat.Determinant() < 0.0f)
-                {
+                if (imesh->mMat.Determinant() < 0.0f) {
                     /* we *must* have normals */
                     for (pvCurrent = mesh->mVertices, t2 = mesh->mNormals; pvCurrent != pvEnd; ++pvCurrent, ++t2) {
                         pvCurrent->x *= -1.f;
@@ -500,17 +467,15 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
                 }
 
                 // Handle pivot point
-                if (pivot.x || pivot.y || pivot.z)
-                {
-                    for (pvCurrent = mesh->mVertices; pvCurrent != pvEnd; ++pvCurrent)  {
+                if (pivot.x || pivot.y || pivot.z) {
+                    for (pvCurrent = mesh->mVertices; pvCurrent != pvEnd; ++pvCurrent) {
                         *pvCurrent -= pivot;
                     }
                 }
 
-                mesh->mColors[1] = (aiColor4D*)1;
-            }
-            else
-                mesh->mColors[1] = (aiColor4D*)1;
+                mesh->mColors[1] = (aiColor4D *)1;
+            } else
+                mesh->mColors[1] = (aiColor4D *)1;
 
             // Setup the mesh index
             pcOut->mMeshes[i] = iIndex;
@@ -519,78 +484,75 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
 
     // Setup the name of the node
     // First instance keeps its name otherwise something might break, all others will be postfixed with their instance number
-    if (pcIn->mInstanceNumber > 1)
-    {
+    if (pcIn->mInstanceNumber > 1) {
         char tmp[12];
         ASSIMP_itoa10(tmp, pcIn->mInstanceNumber);
         std::string tempStr = pcIn->mName + "_inst_";
         tempStr += tmp;
         pcOut->mName.Set(tempStr);
-    }
-    else
+    } else
         pcOut->mName.Set(pcIn->mName);
 
     // Now build the transformation matrix of the node
     // ROTATION
-    if (pcIn->aRotationKeys.size()){
+    if (pcIn->aRotationKeys.size()) {
 
         // FIX to get to Assimp's quaternion conventions
         for (std::vector<aiQuatKey>::iterator it = pcIn->aRotationKeys.begin(); it != pcIn->aRotationKeys.end(); ++it) {
             (*it).mValue.w *= -1.f;
         }
 
-        pcOut->mTransformation = aiMatrix4x4( pcIn->aRotationKeys[0].mValue.GetMatrix() );
-    }
-    else if (pcIn->aCameraRollKeys.size())
-    {
-        aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(- pcIn->aCameraRollKeys[0].mValue),
-            pcOut->mTransformation);
+        pcOut->mTransformation = aiMatrix4x4(pcIn->aRotationKeys[0].mValue.GetMatrix());
+    } else if (pcIn->aCameraRollKeys.size()) {
+        aiMatrix4x4::RotationZ(AI_DEG_TO_RAD(-pcIn->aCameraRollKeys[0].mValue),
+                pcOut->mTransformation);
     }
 
     // SCALING
-    aiMatrix4x4& m = pcOut->mTransformation;
-    if (pcIn->aScalingKeys.size())
-    {
-        const aiVector3D& v = pcIn->aScalingKeys[0].mValue;
-        m.a1 *= v.x; m.b1 *= v.x; m.c1 *= v.x;
-        m.a2 *= v.y; m.b2 *= v.y; m.c2 *= v.y;
-        m.a3 *= v.z; m.b3 *= v.z; m.c3 *= v.z;
+    aiMatrix4x4 &m = pcOut->mTransformation;
+    if (pcIn->aScalingKeys.size()) {
+        const aiVector3D &v = pcIn->aScalingKeys[0].mValue;
+        m.a1 *= v.x;
+        m.b1 *= v.x;
+        m.c1 *= v.x;
+        m.a2 *= v.y;
+        m.b2 *= v.y;
+        m.c2 *= v.y;
+        m.a3 *= v.z;
+        m.b3 *= v.z;
+        m.c3 *= v.z;
     }
 
     // TRANSLATION
-    if (pcIn->aPositionKeys.size())
-    {
-        const aiVector3D& v = pcIn->aPositionKeys[0].mValue;
+    if (pcIn->aPositionKeys.size()) {
+        const aiVector3D &v = pcIn->aPositionKeys[0].mValue;
         m.a4 += v.x;
         m.b4 += v.y;
         m.c4 += v.z;
     }
 
     // Generate animation channels for the node
-    if (pcIn->aPositionKeys.size()  > 1  || pcIn->aRotationKeys.size()   > 1 ||
-        pcIn->aScalingKeys.size()   > 1  || pcIn->aCameraRollKeys.size() > 1 ||
-        pcIn->aTargetPositionKeys.size() > 1)
-    {
-        aiAnimation* anim = pcSOut->mAnimations[0];
+    if (pcIn->aPositionKeys.size() > 1 || pcIn->aRotationKeys.size() > 1 ||
+            pcIn->aScalingKeys.size() > 1 || pcIn->aCameraRollKeys.size() > 1 ||
+            pcIn->aTargetPositionKeys.size() > 1) {
+        aiAnimation *anim = pcSOut->mAnimations[0];
         ai_assert(nullptr != anim);
 
-        if (pcIn->aCameraRollKeys.size() > 1)
-        {
+        if (pcIn->aCameraRollKeys.size() > 1) {
             ASSIMP_LOG_DEBUG("3DS: Converting camera roll track ...");
 
             // Camera roll keys - in fact they're just rotations
             // around the camera's z axis. The angles are given
             // in degrees (and they're clockwise).
             pcIn->aRotationKeys.resize(pcIn->aCameraRollKeys.size());
-            for (unsigned int i = 0; i < pcIn->aCameraRollKeys.size();++i)
-            {
-                aiQuatKey&  q = pcIn->aRotationKeys[i];
-                aiFloatKey& f = pcIn->aCameraRollKeys[i];
+            for (unsigned int i = 0; i < pcIn->aCameraRollKeys.size(); ++i) {
+                aiQuatKey &q = pcIn->aRotationKeys[i];
+                aiFloatKey &f = pcIn->aCameraRollKeys[i];
 
-                q.mTime  = f.mTime;
+                q.mTime = f.mTime;
 
                 // FIX to get to Assimp quaternion conventions
-                q.mValue = aiQuaternion(0.f,0.f,AI_DEG_TO_RAD( /*-*/ f.mValue));
+                q.mValue = aiQuaternion(0.f, 0.f, AI_DEG_TO_RAD(/*-*/ f.mValue));
             }
         }
 #if 0
@@ -636,102 +598,93 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
         // Cameras or lights define their transformation in their parent node and in the
         // corresponding light or camera chunks. However, we read and process the latter
         // to to be able to return valid cameras/lights even if no scenegraph is given.
-        for (unsigned int n = 0; n < pcSOut->mNumCameras;++n)   {
+        for (unsigned int n = 0; n < pcSOut->mNumCameras; ++n) {
             if (pcSOut->mCameras[n]->mName == pcOut->mName) {
-                pcSOut->mCameras[n]->mLookAt = aiVector3D(0.f,0.f,1.f);
+                pcSOut->mCameras[n]->mLookAt = aiVector3D(0.f, 0.f, 1.f);
             }
         }
-        for (unsigned int n = 0; n < pcSOut->mNumLights;++n)    {
+        for (unsigned int n = 0; n < pcSOut->mNumLights; ++n) {
             if (pcSOut->mLights[n]->mName == pcOut->mName) {
-                pcSOut->mLights[n]->mDirection = aiVector3D(0.f,0.f,1.f);
+                pcSOut->mLights[n]->mDirection = aiVector3D(0.f, 0.f, 1.f);
             }
         }
 
         // Allocate a new node anim and setup its name
-        aiNodeAnim* nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
+        aiNodeAnim *nda = anim->mChannels[anim->mNumChannels++] = new aiNodeAnim();
         nda->mNodeName.Set(pcIn->mName);
 
         // POSITION keys
-        if (pcIn->aPositionKeys.size()  > 0)
-        {
+        if (pcIn->aPositionKeys.size() > 0) {
             nda->mNumPositionKeys = (unsigned int)pcIn->aPositionKeys.size();
             nda->mPositionKeys = new aiVectorKey[nda->mNumPositionKeys];
-            ::memcpy(nda->mPositionKeys,&pcIn->aPositionKeys[0],
-                sizeof(aiVectorKey)*nda->mNumPositionKeys);
+            ::memcpy(nda->mPositionKeys, &pcIn->aPositionKeys[0],
+                    sizeof(aiVectorKey) * nda->mNumPositionKeys);
         }
 
         // ROTATION keys
-        if (pcIn->aRotationKeys.size()  > 0)
-        {
+        if (pcIn->aRotationKeys.size() > 0) {
             nda->mNumRotationKeys = (unsigned int)pcIn->aRotationKeys.size();
             nda->mRotationKeys = new aiQuatKey[nda->mNumRotationKeys];
 
             // Rotations are quaternion offsets
             aiQuaternion abs1;
-            for (unsigned int n = 0; n < nda->mNumRotationKeys;++n)
-            {
-                const aiQuatKey& q = pcIn->aRotationKeys[n];
+            for (unsigned int n = 0; n < nda->mNumRotationKeys; ++n) {
+                const aiQuatKey &q = pcIn->aRotationKeys[n];
 
                 abs1 = (n ? abs1 * q.mValue : q.mValue);
-                nda->mRotationKeys[n].mTime  = q.mTime;
+                nda->mRotationKeys[n].mTime = q.mTime;
                 nda->mRotationKeys[n].mValue = abs1.Normalize();
             }
         }
 
         // SCALING keys
-        if (pcIn->aScalingKeys.size()  > 0)
-        {
+        if (pcIn->aScalingKeys.size() > 0) {
             nda->mNumScalingKeys = (unsigned int)pcIn->aScalingKeys.size();
             nda->mScalingKeys = new aiVectorKey[nda->mNumScalingKeys];
-            ::memcpy(nda->mScalingKeys,&pcIn->aScalingKeys[0],
-                sizeof(aiVectorKey)*nda->mNumScalingKeys);
+            ::memcpy(nda->mScalingKeys, &pcIn->aScalingKeys[0],
+                    sizeof(aiVectorKey) * nda->mNumScalingKeys);
         }
     }
 
     // Allocate storage for children
     pcOut->mNumChildren = (unsigned int)pcIn->mChildren.size();
-    pcOut->mChildren = new aiNode*[pcIn->mChildren.size()];
+    pcOut->mChildren = new aiNode *[pcIn->mChildren.size()];
 
     // Recursively process all children
     const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
-    for (unsigned int i = 0; i < size;++i)
-    {
+    for (unsigned int i = 0; i < size; ++i) {
         pcOut->mChildren[i] = new aiNode();
         pcOut->mChildren[i]->mParent = pcOut;
-        AddNodeToGraph(pcSOut,pcOut->mChildren[i],pcIn->mChildren[i],abs);
+        AddNodeToGraph(pcSOut, pcOut->mChildren[i], pcIn->mChildren[i], abs);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find out how many node animation channels we'll have finally
-void CountTracks(D3DS::Node* node, unsigned int& cnt)
-{
+void CountTracks(D3DS::Node *node, unsigned int &cnt) {
     //////////////////////////////////////////////////////////////////////////////
     // We will never generate more than one channel for a node, so
     // this is rather easy here.
 
-    if (node->aPositionKeys.size()  > 1  || node->aRotationKeys.size()   > 1   ||
-        node->aScalingKeys.size()   > 1  || node->aCameraRollKeys.size() > 1 ||
-        node->aTargetPositionKeys.size()  > 1)
-    {
+    if (node->aPositionKeys.size() > 1 || node->aRotationKeys.size() > 1 ||
+            node->aScalingKeys.size() > 1 || node->aCameraRollKeys.size() > 1 ||
+            node->aTargetPositionKeys.size() > 1) {
         ++cnt;
 
         // account for the additional channel for the camera/spotlight target position
-        if (node->aTargetPositionKeys.size()  > 1)++cnt;
+        if (node->aTargetPositionKeys.size() > 1) ++cnt;
     }
 
     // Recursively process all children
-    for (unsigned int i = 0; i < node->mChildren.size();++i)
-        CountTracks(node->mChildren[i],cnt);
+    for (unsigned int i = 0; i < node->mChildren.size(); ++i)
+        CountTracks(node->mChildren[i], cnt);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Generate the output node graph
-void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
-{
+void Discreet3DSImporter::GenerateNodeGraph(aiScene *pcOut) {
     pcOut->mRootNode = new aiNode();
-    if (0 == mRootNode->mChildren.size())
-    {
+    if (0 == mRootNode->mChildren.size()) {
         //////////////////////////////////////////////////////////////////////////////
         // It seems the file is so messed up that it has not even a hierarchy.
         // generate a flat hiearachy which looks like this:
@@ -745,29 +698,27 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
         ASSIMP_LOG_WARN("No hierarchy information has been found in the file. ");
 
         pcOut->mRootNode->mNumChildren = pcOut->mNumMeshes +
-            static_cast<unsigned int>(mScene->mCameras.size() + mScene->mLights.size());
+                                         static_cast<unsigned int>(mScene->mCameras.size() + mScene->mLights.size());
 
-        pcOut->mRootNode->mChildren = new aiNode* [ pcOut->mRootNode->mNumChildren ];
+        pcOut->mRootNode->mChildren = new aiNode *[pcOut->mRootNode->mNumChildren];
         pcOut->mRootNode->mName.Set("<3DSDummyRoot>");
 
         // Build dummy nodes for all meshes
         unsigned int a = 0;
-        for (unsigned int i = 0; i < pcOut->mNumMeshes;++i,++a)
-        {
-            aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+        for (unsigned int i = 0; i < pcOut->mNumMeshes; ++i, ++a) {
+            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
             pcNode->mMeshes = new unsigned int[1];
             pcNode->mMeshes[0] = i;
             pcNode->mNumMeshes = 1;
 
             // Build a name for the node
-            pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "3DSMesh_%u",i);
+            pcNode->mName.length = ai_snprintf(pcNode->mName.data, MAXLEN, "3DSMesh_%u", i);
         }
 
         // Build dummy nodes for all cameras
-        for (unsigned int i = 0; i < (unsigned int )mScene->mCameras.size();++i,++a)
-        {
-            aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+        for (unsigned int i = 0; i < (unsigned int)mScene->mCameras.size(); ++i, ++a) {
+            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
 
             // Build a name for the node
@@ -775,75 +726,68 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
         }
 
         // Build dummy nodes for all lights
-        for (unsigned int i = 0; i < (unsigned int )mScene->mLights.size();++i,++a)
-        {
-            aiNode* pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
+        for (unsigned int i = 0; i < (unsigned int)mScene->mLights.size(); ++i, ++a) {
+            aiNode *pcNode = pcOut->mRootNode->mChildren[a] = new aiNode();
             pcNode->mParent = pcOut->mRootNode;
 
             // Build a name for the node
             pcNode->mName = mScene->mLights[i]->mName;
         }
-    }
-    else
-    {
+    } else {
         // First of all: find out how many scaling, rotation and translation
         // animation tracks we'll have afterwards
         unsigned int numChannel = 0;
-        CountTracks(mRootNode,numChannel);
+        CountTracks(mRootNode, numChannel);
 
-        if (numChannel)
-        {
+        if (numChannel) {
             // Allocate a primary animation channel
             pcOut->mNumAnimations = 1;
-            pcOut->mAnimations    = new aiAnimation*[1];
-            aiAnimation* anim     = pcOut->mAnimations[0] = new aiAnimation();
+            pcOut->mAnimations = new aiAnimation *[1];
+            aiAnimation *anim = pcOut->mAnimations[0] = new aiAnimation();
 
             anim->mName.Set("3DSMasterAnim");
 
             // Allocate enough storage for all node animation channels,
             // but don't set the mNumChannels member - we'll use it to
             // index into the array
-            anim->mChannels = new aiNodeAnim*[numChannel];
+            anim->mChannels = new aiNodeAnim *[numChannel];
         }
 
         aiMatrix4x4 m;
-        AddNodeToGraph(pcOut,  pcOut->mRootNode, mRootNode,m);
+        AddNodeToGraph(pcOut, pcOut->mRootNode, mRootNode, m);
     }
 
     // We used the first and second vertex color set to store some temporary values so we need to cleanup here
-    for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a)
-    {
-        pcOut->mMeshes[a]->mColors[0] = NULL;
-        pcOut->mMeshes[a]->mColors[1] = NULL;
+    for (unsigned int a = 0; a < pcOut->mNumMeshes; ++a) {
+        pcOut->mMeshes[a]->mColors[0] = nullptr;
+        pcOut->mMeshes[a]->mColors[1] = nullptr;
     }
 
     pcOut->mRootNode->mTransformation = aiMatrix4x4(
-        1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,
-        0.f,-1.f,0.f,0.f,
-        0.f,0.f,0.f,1.f) * pcOut->mRootNode->mTransformation;
+                                                1.f, 0.f, 0.f, 0.f,
+                                                0.f, 0.f, 1.f, 0.f,
+                                                0.f, -1.f, 0.f, 0.f,
+                                                0.f, 0.f, 0.f, 1.f) *
+                                        pcOut->mRootNode->mTransformation;
 
     // If the root node is unnamed name it "<3DSRoot>"
-    if (::strstr( pcOut->mRootNode->mName.data, "UNNAMED" ) ||
-        (pcOut->mRootNode->mName.data[0] == '$' && pcOut->mRootNode->mName.data[1] == '$') )
-    {
+    if (::strstr(pcOut->mRootNode->mName.data, "UNNAMED") ||
+            (pcOut->mRootNode->mName.data[0] == '$' && pcOut->mRootNode->mName.data[1] == '$')) {
         pcOut->mRootNode->mName.Set("<3DSRoot>");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert all meshes in the scene and generate the final output scene.
-void Discreet3DSImporter::ConvertScene(aiScene* pcOut)
-{
+void Discreet3DSImporter::ConvertScene(aiScene *pcOut) {
     // Allocate enough storage for all output materials
     pcOut->mNumMaterials = (unsigned int)mScene->mMaterials.size();
-    pcOut->mMaterials    = new aiMaterial*[pcOut->mNumMaterials];
+    pcOut->mMaterials = new aiMaterial *[pcOut->mNumMaterials];
 
     //  ... and convert the 3DS materials to aiMaterial's
-    for (unsigned int i = 0; i < pcOut->mNumMaterials;++i)
-    {
-        aiMaterial* pcNew = new aiMaterial();
-        ConvertMaterial(mScene->mMaterials[i],*pcNew);
+    for (unsigned int i = 0; i < pcOut->mNumMaterials; ++i) {
+        aiMaterial *pcNew = new aiMaterial();
+        ConvertMaterial(mScene->mMaterials[i], *pcNew);
         pcOut->mMaterials[i] = pcNew;
     }
 
@@ -852,18 +796,16 @@ void Discreet3DSImporter::ConvertScene(aiScene* pcOut)
 
     // Now copy all light sources to the output scene
     pcOut->mNumLights = (unsigned int)mScene->mLights.size();
-    if (pcOut->mNumLights)
-    {
-        pcOut->mLights = new aiLight*[pcOut->mNumLights];
-        ::memcpy(pcOut->mLights,&mScene->mLights[0],sizeof(void*)*pcOut->mNumLights);
+    if (pcOut->mNumLights) {
+        pcOut->mLights = new aiLight *[pcOut->mNumLights];
+        ::memcpy(pcOut->mLights, &mScene->mLights[0], sizeof(void *) * pcOut->mNumLights);
     }
 
     // Now copy all cameras to the output scene
     pcOut->mNumCameras = (unsigned int)mScene->mCameras.size();
-    if (pcOut->mNumCameras)
-    {
-        pcOut->mCameras = new aiCamera*[pcOut->mNumCameras];
-        ::memcpy(pcOut->mCameras,&mScene->mCameras[0],sizeof(void*)*pcOut->mNumCameras);
+    if (pcOut->mNumCameras) {
+        pcOut->mCameras = new aiCamera *[pcOut->mNumCameras];
+        ::memcpy(pcOut->mCameras, &mScene->mCameras[0], sizeof(void *) * pcOut->mNumCameras);
     }
 }
 
diff --git a/code/3DS/3DSExporter.cpp b/code/AssetLib/3DS/3DSExporter.cpp
similarity index 75%
rename from code/3DS/3DSExporter.cpp
rename to code/AssetLib/3DS/3DSExporter.cpp
index 403ca20a2..5f3d955da 100644
--- a/code/3DS/3DSExporter.cpp
+++ b/code/AssetLib/3DS/3DSExporter.cpp
@@ -43,120 +43,117 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_3DS_EXPORTER
 
-#include "3DS/3DSExporter.h"
-#include "3DS/3DSLoader.h"
-#include "3DS/3DSHelper.h"
+#include "AssetLib/3DS/3DSExporter.h"
+#include "AssetLib/3DS/3DSHelper.h"
+#include "AssetLib/3DS/3DSLoader.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
 #include <assimp/SceneCombiner.h>
 #include <assimp/StringComparison.h>
-#include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
 using namespace Assimp;
-namespace Assimp    {
+namespace Assimp {
 using namespace D3DS;
 
 namespace {
 
-    //////////////////////////////////////////////////////////////////////////////////////
-    // Scope utility to write a 3DS file chunk.
-    //
-    // Upon construction, the chunk header is written with the chunk type (flags)
-    // filled out, but the chunk size left empty. Upon destruction, the correct chunk
-    // size based on the then-position of the output stream cursor is filled in.
-    class ChunkWriter {
-        enum {
-              CHUNK_SIZE_NOT_SET = 0xdeadbeef
-            , SIZE_OFFSET        = 2
-        };
-    public:
-
-        ChunkWriter(StreamWriterLE& writer, uint16_t chunk_type)
-            : writer(writer)
-        {
-            chunk_start_pos = writer.GetCurrentPos();
-            writer.PutU2(chunk_type);
-            writer.PutU4((uint32_t)CHUNK_SIZE_NOT_SET);
-        }
-
-        ~ChunkWriter() {
-            std::size_t head_pos = writer.GetCurrentPos();
-
-            ai_assert(head_pos > chunk_start_pos);
-            const std::size_t chunk_size = head_pos - chunk_start_pos;
-
-            writer.SetCurrentPos(chunk_start_pos + SIZE_OFFSET);
-            writer.PutU4(static_cast<uint32_t>(chunk_size));
-            writer.SetCurrentPos(head_pos);
-        }
-
-    private:
-        StreamWriterLE& writer;
-        std::size_t chunk_start_pos;
+//////////////////////////////////////////////////////////////////////////////////////
+// Scope utility to write a 3DS file chunk.
+//
+// Upon construction, the chunk header is written with the chunk type (flags)
+// filled out, but the chunk size left empty. Upon destruction, the correct chunk
+// size based on the then-position of the output stream cursor is filled in.
+class ChunkWriter {
+    enum {
+        CHUNK_SIZE_NOT_SET = 0xdeadbeef,
+        SIZE_OFFSET = 2
     };
 
-
-    // Return an unique name for a given |mesh| attached to |node| that
-    // preserves the mesh's given name if it has one. |index| is the index
-    // of the mesh in |aiScene::mMeshes|.
-    std::string GetMeshName(const aiMesh& mesh, unsigned int index, const aiNode& node) {
-        static const std::string underscore = "_";
-        char postfix[10] = {0};
-        ASSIMP_itoa10(postfix, index);
-
-        std::string result = node.mName.C_Str();
-        if (mesh.mName.length > 0) {
-            result += underscore + mesh.mName.C_Str();
-        }
-        return result + underscore + postfix;
+public:
+    ChunkWriter(StreamWriterLE &writer, uint16_t chunk_type) :
+            writer(writer) {
+        chunk_start_pos = writer.GetCurrentPos();
+        writer.PutU2(chunk_type);
+        writer.PutU4((uint32_t)CHUNK_SIZE_NOT_SET);
     }
 
-    // Return an unique name for a given |mat| with original position |index|
-    // in |aiScene::mMaterials|. The name preserves the original material
-    // name if possible.
-    std::string GetMaterialName(const aiMaterial& mat, unsigned int index) {
-        static const std::string underscore = "_";
-        char postfix[10] = {0};
-        ASSIMP_itoa10(postfix, index);
+    ~ChunkWriter() {
+        std::size_t head_pos = writer.GetCurrentPos();
 
-        aiString mat_name;
-        if (AI_SUCCESS == mat.Get(AI_MATKEY_NAME, mat_name)) {
-            return mat_name.C_Str() + underscore + postfix;
-        }
+        ai_assert(head_pos > chunk_start_pos);
+        const std::size_t chunk_size = head_pos - chunk_start_pos;
 
-        return "Material" + underscore + postfix;
+        writer.SetCurrentPos(chunk_start_pos + SIZE_OFFSET);
+        writer.PutU4(static_cast<uint32_t>(chunk_size));
+        writer.SetCurrentPos(head_pos);
     }
 
-    // Collect world transformations for each node
-    void CollectTrafos(const aiNode* node, std::map<const aiNode*, aiMatrix4x4>& trafos) {
-        const aiMatrix4x4& parent = node->mParent ? trafos[node->mParent] : aiMatrix4x4();
-        trafos[node] = parent * node->mTransformation;
-        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-            CollectTrafos(node->mChildren[i], trafos);
-        }
+private:
+    StreamWriterLE &writer;
+    std::size_t chunk_start_pos;
+};
+
+// Return an unique name for a given |mesh| attached to |node| that
+// preserves the mesh's given name if it has one. |index| is the index
+// of the mesh in |aiScene::mMeshes|.
+std::string GetMeshName(const aiMesh &mesh, unsigned int index, const aiNode &node) {
+    static const std::string underscore = "_";
+    char postfix[10] = { 0 };
+    ASSIMP_itoa10(postfix, index);
+
+    std::string result = node.mName.C_Str();
+    if (mesh.mName.length > 0) {
+        result += underscore + mesh.mName.C_Str();
+    }
+    return result + underscore + postfix;
+}
+
+// Return an unique name for a given |mat| with original position |index|
+// in |aiScene::mMaterials|. The name preserves the original material
+// name if possible.
+std::string GetMaterialName(const aiMaterial &mat, unsigned int index) {
+    static const std::string underscore = "_";
+    char postfix[10] = { 0 };
+    ASSIMP_itoa10(postfix, index);
+
+    aiString mat_name;
+    if (AI_SUCCESS == mat.Get(AI_MATKEY_NAME, mat_name)) {
+        return mat_name.C_Str() + underscore + postfix;
     }
 
-    // Generate a flat list of the meshes (by index) assigned to each node
-    void CollectMeshes(const aiNode* node, std::multimap<const aiNode*, unsigned int>& meshes) {
-        for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
-            meshes.insert(std::make_pair(node, node->mMeshes[i]));
-        }
-        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
-            CollectMeshes(node->mChildren[i], meshes);
-        }
+    return "Material" + underscore + postfix;
+}
+
+// Collect world transformations for each node
+void CollectTrafos(const aiNode *node, std::map<const aiNode *, aiMatrix4x4> &trafos) {
+    const aiMatrix4x4 &parent = node->mParent ? trafos[node->mParent] : aiMatrix4x4();
+    trafos[node] = parent * node->mTransformation;
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        CollectTrafos(node->mChildren[i], trafos);
     }
 }
 
+// Generate a flat list of the meshes (by index) assigned to each node
+void CollectMeshes(const aiNode *node, std::multimap<const aiNode *, unsigned int> &meshes) {
+    for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+        meshes.insert(std::make_pair(node, node->mMeshes[i]));
+    }
+    for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+        CollectMeshes(node->mChildren[i], meshes);
+    }
+}
+} // namespace
+
 // ------------------------------------------------------------------------------------------------
 // Worker function for exporting a scene to 3DS. Prototyped and registered in Exporter.cpp
-void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/)
-{
-    std::shared_ptr<IOStream> outfile (pIOSystem->Open(pFile, "wb"));
-    if(!outfile) {
+void ExportScene3DS(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    std::shared_ptr<IOStream> outfile(pIOSystem->Open(pFile, "wb"));
+    if (!outfile) {
         throw DeadlyExportError("Could not open output .3ds file: " + std::string(pFile));
     }
 
@@ -167,8 +164,8 @@ void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScen
     // SplitLargeMeshes can do this, but it requires the correct limit to be set
     // which is not possible with the current way of specifying preprocess steps
     // in |Exporter::ExportFormatEntry|.
-    aiScene* scenecopy_tmp;
-    SceneCombiner::CopyScene(&scenecopy_tmp,pScene);
+    aiScene *scenecopy_tmp;
+    SceneCombiner::CopyScene(&scenecopy_tmp, pScene);
     std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
 
     SplitLargeMeshesProcess_Triangle tri_splitter;
@@ -186,10 +183,8 @@ void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScen
 } // end of namespace Assimp
 
 // ------------------------------------------------------------------------------------------------
-Discreet3DSExporter:: Discreet3DSExporter(std::shared_ptr<IOStream> &outfile, const aiScene* scene)
-: scene(scene)
-, writer(outfile)
-{
+Discreet3DSExporter::Discreet3DSExporter(std::shared_ptr<IOStream> &outfile, const aiScene *scene) :
+        scene(scene), writer(outfile) {
     CollectTrafos(scene->mRootNode, trafos);
     CollectMeshes(scene->mRootNode, meshes);
 
@@ -217,10 +212,8 @@ Discreet3DSExporter::~Discreet3DSExporter() {
     // empty
 }
 
-
 // ------------------------------------------------------------------------------------------------
-int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling_level)
-{
+int Discreet3DSExporter::WriteHierarchy(const aiNode &node, int seq, int sibling_level) {
     // 3DS scene hierarchy is serialized as in http://www.martinreddy.net/gfx/3d/3DS.spec
     {
         ChunkWriter curRootChunk(writer, Discreet3DS::CHUNK_TRACKINFO);
@@ -237,7 +230,7 @@ int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling
 
             int16_t hierarchy_pos = static_cast<int16_t>(seq);
             if (sibling_level != -1) {
-                hierarchy_pos =(uint16_t) sibling_level;
+                hierarchy_pos = (uint16_t)sibling_level;
             }
 
             // Write the hierarchy position
@@ -260,7 +253,7 @@ int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling
         const bool first_child = node.mNumChildren == 0 && i == 0;
 
         const unsigned int mesh_idx = node.mMeshes[i];
-        const aiMesh& mesh = *scene->mMeshes[mesh_idx];
+        const aiMesh &mesh = *scene->mMeshes[mesh_idx];
 
         ChunkWriter curChunk(writer, Discreet3DS::CHUNK_TRACKINFO);
         {
@@ -276,15 +269,14 @@ int Discreet3DSExporter::WriteHierarchy(const aiNode& node, int seq, int sibling
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteMaterials()
-{
+void Discreet3DSExporter::WriteMaterials() {
     for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
         ChunkWriter curRootChunk(writer, Discreet3DS::CHUNK_MAT_MATERIAL);
-        const aiMaterial& mat = *scene->mMaterials[i];
+        const aiMaterial &mat = *scene->mMaterials[i];
 
         {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_MATNAME);
-            const std::string& name = GetMaterialName(mat, i);
+            const std::string &name = GetMaterialName(mat, i);
             WriteString(name);
         }
 
@@ -314,7 +306,7 @@ void Discreet3DSExporter::WriteMaterials()
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SHADING);
 
             Discreet3DS::shadetype3ds shading_mode_out;
-            switch(shading_mode) {
+            switch (shading_mode) {
             case aiShadingMode_Flat:
             case aiShadingMode_NoShading:
                 shading_mode_out = Discreet3DS::Flat;
@@ -341,7 +333,6 @@ void Discreet3DSExporter::WriteMaterials()
             writer.PutU2(static_cast<uint16_t>(shading_mode_out));
         }
 
-
         float f;
         if (mat.Get(AI_MATKEY_SHININESS, f) == AI_SUCCESS) {
             ChunkWriter chunk(writer, Discreet3DS::CHUNK_MAT_SHININESS);
@@ -370,8 +361,7 @@ void Discreet3DSExporter::WriteMaterials()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteTexture(const aiMaterial& mat, aiTextureType type, uint16_t chunk_flags)
-{
+void Discreet3DSExporter::WriteTexture(const aiMaterial &mat, aiTextureType type, uint16_t chunk_flags) {
     aiString path;
     aiTextureMapMode map_mode[2] = {
         aiTextureMapMode_Wrap, aiTextureMapMode_Wrap
@@ -400,8 +390,7 @@ void Discreet3DSExporter::WriteTexture(const aiMaterial& mat, aiTextureType type
         uint16_t val = 0; // WRAP
         if (map_mode[0] == aiTextureMapMode_Mirror) {
             val = 0x2;
-        }
-        else if (map_mode[0] == aiTextureMapMode_Decal) {
+        } else if (map_mode[0] == aiTextureMapMode_Decal) {
             val = 0x10;
         }
         writer.PutU2(val);
@@ -410,8 +399,7 @@ void Discreet3DSExporter::WriteTexture(const aiMaterial& mat, aiTextureType type
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteMeshes()
-{
+void Discreet3DSExporter::WriteMeshes() {
     // NOTE: 3DS allows for instances. However:
     //   i)  not all importers support reading them
     //   ii) instances are not as flexible as they are in assimp, in particular,
@@ -423,25 +411,24 @@ void Discreet3DSExporter::WriteMeshes()
     // Furthermore, the TRIMESH is transformed into world space so that it will
     // appear correctly if importers don't read the scene hierarchy at all.
     for (MeshesByNodeMap::const_iterator it = meshes.begin(); it != meshes.end(); ++it) {
-        const aiNode& node = *(*it).first;
+        const aiNode &node = *(*it).first;
         const unsigned int mesh_idx = (*it).second;
 
-        const aiMesh& mesh = *scene->mMeshes[mesh_idx];
+        const aiMesh &mesh = *scene->mMeshes[mesh_idx];
 
         // This should not happen if the SLM step is correctly executed
         // before the scene is handed to the exporter
         ai_assert(mesh.mNumVertices <= 0xffff);
         ai_assert(mesh.mNumFaces <= 0xffff);
 
-        const aiMatrix4x4& trafo = trafos[&node];
+        const aiMatrix4x4 &trafo = trafos[&node];
 
         ChunkWriter chunk(writer, Discreet3DS::CHUNK_OBJBLOCK);
 
         // Mesh name is tied to the node it is attached to so it can later be referenced
-        const std::string& name = GetMeshName(mesh, mesh_idx, node);
+        const std::string &name = GetMeshName(mesh, mesh_idx, node);
         WriteString(name);
 
-
         // TRIMESH chunk
         ChunkWriter chunk2(writer, Discreet3DS::CHUNK_TRIMESH);
 
@@ -452,7 +439,7 @@ void Discreet3DSExporter::WriteMeshes()
             const uint16_t count = static_cast<uint16_t>(mesh.mNumVertices);
             writer.PutU2(count);
             for (unsigned int i = 0; i < mesh.mNumVertices; ++i) {
-                const aiVector3D& v = trafo * mesh.mVertices[i];
+                const aiVector3D &v = trafo * mesh.mVertices[i];
                 writer.PutF4(v.x);
                 writer.PutF4(v.y);
                 writer.PutF4(v.z);
@@ -466,7 +453,7 @@ void Discreet3DSExporter::WriteMeshes()
             writer.PutU2(count);
 
             for (unsigned int i = 0; i < mesh.mNumVertices; ++i) {
-                const aiVector3D& v = mesh.mTextureCoords[0][i];
+                const aiVector3D &v = mesh.mTextureCoords[0][i];
                 writer.PutF4(v.x);
                 writer.PutF4(v.y);
             }
@@ -481,7 +468,7 @@ void Discreet3DSExporter::WriteMeshes()
             // Count triangles, discard lines and points
             uint16_t count = 0;
             for (unsigned int i = 0; i < mesh.mNumFaces; ++i) {
-                const aiFace& f = mesh.mFaces[i];
+                const aiFace &f = mesh.mFaces[i];
                 if (f.mNumIndices < 3) {
                     continue;
                 }
@@ -492,7 +479,7 @@ void Discreet3DSExporter::WriteMeshes()
 
             writer.PutU2(count);
             for (unsigned int i = 0; i < mesh.mNumFaces; ++i) {
-                const aiFace& f = mesh.mFaces[i];
+                const aiFace &f = mesh.mFaces[i];
                 if (f.mNumIndices < 3) {
                     continue;
                 }
@@ -524,10 +511,9 @@ void Discreet3DSExporter::WriteMeshes()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh& mesh)
-{
+void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh &mesh) {
     ChunkWriter curChunk(writer, Discreet3DS::CHUNK_FACEMAT);
-    const std::string& name = GetMaterialName(*scene->mMaterials[mesh.mMaterialIndex], mesh.mMaterialIndex);
+    const std::string &name = GetMaterialName(*scene->mMaterials[mesh.mMaterialIndex], mesh.mMaterialIndex);
     WriteString(name);
 
     // Because assimp splits meshes by material, only a single
@@ -542,7 +528,7 @@ void Discreet3DSExporter::WriteFaceMaterialChunk(const aiMesh& mesh)
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteString(const std::string& s) {
+void Discreet3DSExporter::WriteString(const std::string &s) {
     for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {
         writer.PutI1(*it);
     }
@@ -550,7 +536,7 @@ void Discreet3DSExporter::WriteString(const std::string& s) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteString(const aiString& s) {
+void Discreet3DSExporter::WriteString(const aiString &s) {
     for (std::size_t i = 0; i < s.length; ++i) {
         writer.PutI1(s.data[i]);
     }
@@ -558,7 +544,7 @@ void Discreet3DSExporter::WriteString(const aiString& s) {
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSExporter::WriteColor(const aiColor3D& color) {
+void Discreet3DSExporter::WriteColor(const aiColor3D &color) {
     ChunkWriter curChunk(writer, Discreet3DS::CHUNK_RGBF);
     writer.PutF4(color.r);
     writer.PutF4(color.g);
@@ -577,6 +563,5 @@ void Discreet3DSExporter::WritePercentChunk(double f) {
     writer.PutF8(f);
 }
 
-
 #endif // ASSIMP_BUILD_NO_3DS_EXPORTER
 #endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/code/3DS/3DSExporter.h b/code/AssetLib/3DS/3DSExporter.h
similarity index 100%
rename from code/3DS/3DSExporter.h
rename to code/AssetLib/3DS/3DSExporter.h
diff --git a/code/3DS/3DSHelper.h b/code/AssetLib/3DS/3DSHelper.h
similarity index 100%
rename from code/3DS/3DSHelper.h
rename to code/AssetLib/3DS/3DSHelper.h
diff --git a/code/3DS/3DSLoader.cpp b/code/AssetLib/3DS/3DSLoader.cpp
similarity index 69%
rename from code/3DS/3DSLoader.cpp
rename to code/AssetLib/3DS/3DSLoader.cpp
index 13cef3a39..e1a6d0f89 100644
--- a/code/3DS/3DSLoader.cpp
+++ b/code/AssetLib/3DS/3DSLoader.cpp
@@ -45,15 +45,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  http://www.the-labs.com/Blender/3DS-details.html
  */
 
-
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 #include "3DSLoader.h"
-#include <assimp/IOSystem.hpp>
+#include <assimp/StringComparison.h>
+#include <assimp/importerdesc.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-#include <assimp/StringComparison.h>
+#include <assimp/IOSystem.hpp>
 
 using namespace Assimp;
 
@@ -67,26 +66,25 @@ static const aiImporterDesc desc = {
     0,
     0,
     0,
-	"3ds prj"
+    "3ds prj"
 };
 
 // ------------------------------------------------------------------------------------------------
 // Begins a new parsing block
 // - Reads the current chunk and validates it
 // - computes its length
-#define ASSIMP_3DS_BEGIN_CHUNK()                                         \
-    while (true) {                                                       \
-    if (stream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)){ \
-        return;                                                          \
-    }                                                                    \
-    Discreet3DS::Chunk chunk;                                            \
-    ReadChunk(&chunk);                                                   \
-    int chunkSize = chunk.Size-sizeof(Discreet3DS::Chunk);               \
-    if(chunkSize <= 0)                                                   \
-        continue;                                                        \
-    const unsigned int oldReadLimit = stream->SetReadLimit(              \
-        stream->GetCurrentPos() + chunkSize);                            \
-
+#define ASSIMP_3DS_BEGIN_CHUNK()                                              \
+    while (true) {                                                            \
+        if (stream->GetRemainingSizeToLimit() < sizeof(Discreet3DS::Chunk)) { \
+            return;                                                           \
+        }                                                                     \
+        Discreet3DS::Chunk chunk;                                             \
+        ReadChunk(&chunk);                                                    \
+        int chunkSize = chunk.Size - sizeof(Discreet3DS::Chunk);              \
+        if (chunkSize <= 0)                                                   \
+            continue;                                                         \
+        const unsigned int oldReadLimit = stream->SetReadLimit(               \
+                stream->GetCurrentPos() + chunkSize);
 
 // ------------------------------------------------------------------------------------------------
 // End a parsing block
@@ -100,15 +98,8 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-Discreet3DSImporter::Discreet3DSImporter()
-: stream()
-, mLastNodeIndex()
-, mCurrentNode()
-, mRootNode()
-, mScene()
-, mMasterScale()
-, bHasBG()
-, bIsPrj() {
+Discreet3DSImporter::Discreet3DSImporter() :
+        stream(), mLastNodeIndex(), mCurrentNode(), mRootNode(), mScene(), mMasterScale(), bHasBG(), bIsPrj() {
     // empty
 }
 
@@ -120,9 +111,9 @@ Discreet3DSImporter::~Discreet3DSImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool Discreet3DSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const {
+bool Discreet3DSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
     std::string extension = GetExtension(pFile);
-	if(extension == "3ds" || extension == "prj") {
+    if (extension == "3ds" || extension == "prj") {
         return true;
     }
 
@@ -131,29 +122,28 @@ bool Discreet3DSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandle
         token[0] = 0x4d4d;
         token[1] = 0x3dc2;
         //token[2] = 0x3daa;
-        return CheckMagicToken(pIOHandler,pFile,token,2,0,2);
+        return CheckMagicToken(pIOHandler, pFile, token, 2, 0, 2);
     }
     return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader registry entry
-const aiImporterDesc* Discreet3DSImporter::GetInfo () const {
+const aiImporterDesc *Discreet3DSImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/) {
+void Discreet3DSImporter::SetupProperties(const Importer * /*pImp*/) {
     // nothing to be done for the moment
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void Discreet3DSImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
-{
-    StreamReaderLE theStream(pIOHandler->Open(pFile,"rb"));
+void Discreet3DSImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    StreamReaderLE theStream(pIOHandler->Open(pFile, "rb"));
 
     // We should have at least one chunk
     if (theStream.GetRemainingSize() < 16) {
@@ -167,16 +157,16 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
 
     // Initialize members
     D3DS::Node _rootNode("UNNAMED");
-    mLastNodeIndex             = -1;
-    mCurrentNode               = &_rootNode;
-    mRootNode                  = mCurrentNode;
-    mRootNode->mHierarchyPos   = -1;
+    mLastNodeIndex = -1;
+    mCurrentNode = &_rootNode;
+    mRootNode = mCurrentNode;
+    mRootNode->mHierarchyPos = -1;
     mRootNode->mHierarchyIndex = -1;
-    mRootNode->mParent         = NULL;
-    mMasterScale               = 1.0f;
-    mBackgroundImage           = "";
-    bHasBG                     = false;
-    bIsPrj                     = false;
+    mRootNode->mParent = nullptr;
+    mMasterScale = 1.0f;
+    mBackgroundImage = "";
+    bHasBG = false;
+    bIsPrj = false;
 
     // Parse the file
     ParseMainChunk();
@@ -187,11 +177,11 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     // vectors from the smoothing groups we read from the
     // file.
     for (auto &mesh : mScene->mMeshes) {
-        if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0)  {
+        if (mesh.mFaces.size() > 0 && mesh.mPositions.size() == 0) {
             throw DeadlyImportError("3DS file contains faces but no vertices: " + pFile);
         }
         CheckIndices(mesh);
-        MakeUnique  (mesh);
+        MakeUnique(mesh);
         ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
     }
 
@@ -222,25 +212,26 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
 
 // ------------------------------------------------------------------------------------------------
 // Applies a master-scaling factor to the imported scene
-void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene) {
+void Discreet3DSImporter::ApplyMasterScale(aiScene *pScene) {
     // There are some 3DS files with a zero scaling factor
-    if (!mMasterScale)mMasterScale = 1.0f;
-    else mMasterScale = 1.0f / mMasterScale;
+    if (!mMasterScale)
+        mMasterScale = 1.0f;
+    else
+        mMasterScale = 1.0f / mMasterScale;
 
     // Construct an uniform scaling matrix and multiply with it
     pScene->mRootNode->mTransformation *= aiMatrix4x4(
-        mMasterScale,0.0f, 0.0f, 0.0f,
-        0.0f, mMasterScale,0.0f, 0.0f,
-        0.0f, 0.0f, mMasterScale,0.0f,
-        0.0f, 0.0f, 0.0f, 1.0f);
+            mMasterScale, 0.0f, 0.0f, 0.0f,
+            0.0f, mMasterScale, 0.0f, 0.0f,
+            0.0f, 0.0f, mMasterScale, 0.0f,
+            0.0f, 0.0f, 0.0f, 1.0f);
 
     // Check whether a scaling track is assigned to the root node.
 }
 
 // ------------------------------------------------------------------------------------------------
 // Reads a new chunk from the file
-void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk* pcOut)
-{
+void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk *pcOut) {
     ai_assert(pcOut != nullptr);
 
     pcOut->Flag = stream->GetI2();
@@ -257,24 +248,21 @@ void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk* pcOut)
 
 // ------------------------------------------------------------------------------------------------
 // Skip a chunk
-void Discreet3DSImporter::SkipChunk()
-{
+void Discreet3DSImporter::SkipChunk() {
     Discreet3DS::Chunk psChunk;
     ReadChunk(&psChunk);
 
-    stream->IncPtr(psChunk.Size-sizeof(Discreet3DS::Chunk));
+    stream->IncPtr(psChunk.Size - sizeof(Discreet3DS::Chunk));
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Process the primary chunk of the file
-void Discreet3DSImporter::ParseMainChunk()
-{
+void Discreet3DSImporter::ParseMainChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
 
     case Discreet3DS::CHUNK_PRJ:
         bIsPrj = true;
@@ -289,13 +277,11 @@ void Discreet3DSImporter::ParseMainChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseEditorChunk()
-{
+void Discreet3DSImporter::ParseEditorChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_OBJMESH:
 
         ParseObjectChunk();
@@ -308,36 +294,31 @@ void Discreet3DSImporter::ParseEditorChunk()
         ParseKeyframeChunk();
         break;
 
-    case Discreet3DS::CHUNK_VERSION:
-        {
+    case Discreet3DS::CHUNK_VERSION: {
         // print the version number
         char buff[10];
-        ASSIMP_itoa10(buff,stream->GetI2());
+        ASSIMP_itoa10(buff, stream->GetI2());
         ASSIMP_LOG_INFO_F(std::string("3DS file format version: "), buff);
-        }
-        break;
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseObjectChunk()
-{
+void Discreet3DSImporter::ParseObjectChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_OBJBLOCK:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_OBJBLOCK: {
         unsigned int cnt = 0;
-        const char* sz = (const char*)stream->GetPtr();
+        const char *sz = (const char *)stream->GetPtr();
 
         // Get the name of the geometry object
-        while (stream->GetI1())++cnt;
-        ParseChunk(sz,cnt);
-        }
-        break;
+        while (stream->GetI1())
+            ++cnt;
+        ParseChunk(sz, cnt);
+    } break;
 
     case Discreet3DS::CHUNK_MAT_MATERIAL:
 
@@ -350,25 +331,23 @@ void Discreet3DSImporter::ParseObjectChunk()
 
         // This is the ambient base color of the scene.
         // We add it to the ambient color of all materials
-        ParseColorChunk(&mClrAmbient,true);
-        if (is_qnan(mClrAmbient.r))
-        {
+        ParseColorChunk(&mClrAmbient, true);
+        if (is_qnan(mClrAmbient.r)) {
             // We failed to read the ambient base color.
             ASSIMP_LOG_ERROR("3DS: Failed to read ambient base color");
             mClrAmbient.r = mClrAmbient.g = mClrAmbient.b = 0.0f;
         }
         break;
 
-    case Discreet3DS::CHUNK_BIT_MAP:
-        {
+    case Discreet3DS::CHUNK_BIT_MAP: {
         // Specifies the background image. The string should already be
         // properly 0 terminated but we need to be sure
         unsigned int cnt = 0;
-        const char* sz = (const char*)stream->GetPtr();
-        while (stream->GetI1())++cnt;
-        mBackgroundImage = std::string(sz,cnt);
-        }
-        break;
+        const char *sz = (const char *)stream->GetPtr();
+        while (stream->GetI1())
+            ++cnt;
+        mBackgroundImage = std::string(sz, cnt);
+    } break;
 
     case Discreet3DS::CHUNK_BIT_MAP_EXISTS:
         bHasBG = true;
@@ -383,8 +362,7 @@ void Discreet3DSImporter::ParseObjectChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
-{
+void Discreet3DSImporter::ParseChunk(const char *name, unsigned int num) {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // IMPLEMENTATION NOTE;
@@ -393,22 +371,18 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
     // to to be able to return valid cameras/lights even if no scenegraph is given.
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_TRIMESH:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_TRIMESH: {
         // this starts a new triangle mesh
         mScene->mMeshes.push_back(D3DS::Mesh(std::string(name, num)));
 
         // Read mesh chunks
         ParseMeshChunk();
-        }
-        break;
+    } break;
 
-    case Discreet3DS::CHUNK_LIGHT:
-        {
+    case Discreet3DS::CHUNK_LIGHT: {
         // This starts a new light
-        aiLight* light = new aiLight();
+        aiLight *light = new aiLight();
         mScene->mLights.push_back(light);
 
         light->mName.Set(std::string(name, num));
@@ -418,7 +392,7 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
         light->mPosition.y = stream->GetF4();
         light->mPosition.z = stream->GetF4();
 
-        light->mColorDiffuse = aiColor3D(1.f,1.f,1.f);
+        light->mColorDiffuse = aiColor3D(1.f, 1.f, 1.f);
 
         // Now check for further subchunks
         if (!bIsPrj) /* fixme */
@@ -427,19 +401,17 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
         // The specular light color is identical the the diffuse light color. The ambient light color
         // is equal to the ambient base color of the whole scene.
         light->mColorSpecular = light->mColorDiffuse;
-        light->mColorAmbient  = mClrAmbient;
+        light->mColorAmbient = mClrAmbient;
 
-        if (light->mType == aiLightSource_UNDEFINED)
-        {
+        if (light->mType == aiLightSource_UNDEFINED) {
             // It must be a point light
             light->mType = aiLightSource_POINT;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_CAMERA:
-        {
+    case Discreet3DS::CHUNK_CAMERA: {
         // This starts a new camera
-        aiCamera* camera = new aiCamera();
+        aiCamera *camera = new aiCamera();
         mScene->mCameras.push_back(camera);
         camera->mName.Set(std::string(name, num));
 
@@ -457,40 +429,38 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
 
             // There are some files with lookat == position. Don't know why or whether it's ok or not.
             ASSIMP_LOG_ERROR("3DS: Unable to read proper camera look-at vector");
-            camera->mLookAt = aiVector3D(0.0,1.0,0.0);
+            camera->mLookAt = aiVector3D(0.0, 1.0, 0.0);
 
-        }
-        else camera->mLookAt /= len;
+        } else
+            camera->mLookAt /= len;
 
         // And finally - the camera rotation angle, in counter clockwise direction
-        const ai_real angle =  AI_DEG_TO_RAD( stream->GetF4() );
-        aiQuaternion quat(camera->mLookAt,angle);
-        camera->mUp = quat.GetMatrix() * aiVector3D(0.0,1.0,0.0);
+        const ai_real angle = AI_DEG_TO_RAD(stream->GetF4());
+        aiQuaternion quat(camera->mLookAt, angle);
+        camera->mUp = quat.GetMatrix() * aiVector3D(0.0, 1.0, 0.0);
 
         // Read the lense angle
-        camera->mHorizontalFOV = AI_DEG_TO_RAD ( stream->GetF4() );
-        if (camera->mHorizontalFOV < 0.001f)  {
+        camera->mHorizontalFOV = AI_DEG_TO_RAD(stream->GetF4());
+        if (camera->mHorizontalFOV < 0.001f) {
             camera->mHorizontalFOV = AI_DEG_TO_RAD(45.f);
         }
 
         // Now check for further subchunks
         if (!bIsPrj) /* fixme */ {
             ParseCameraChunk();
-        }}
-        break;
+        }
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseLightChunk()
-{
+void Discreet3DSImporter::ParseLightChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
-    aiLight* light = mScene->mLights.back();
+    aiLight *light = mScene->mLights.back();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_DL_SPOTLIGHT:
         // Now we can be sure that the light is a spot light
         light->mType = aiLightSource_SPOT;
@@ -502,10 +472,10 @@ void Discreet3DSImporter::ParseLightChunk()
         light->mDirection.Normalize();
 
         // Now the hotspot and falloff angles - in degrees
-        light->mAngleInnerCone = AI_DEG_TO_RAD( stream->GetF4() );
+        light->mAngleInnerCone = AI_DEG_TO_RAD(stream->GetF4());
 
         // FIX: the falloff angle is just an offset
-        light->mAngleOuterCone = light->mAngleInnerCone+AI_DEG_TO_RAD( stream->GetF4() );
+        light->mAngleOuterCone = light->mAngleInnerCone + AI_DEG_TO_RAD(stream->GetF4());
         break;
 
         // intensity multiplier
@@ -531,18 +501,16 @@ void Discreet3DSImporter::ParseLightChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseCameraChunk()
-{
+void Discreet3DSImporter::ParseCameraChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
-    aiCamera* camera = mScene->mCameras.back();
+    aiCamera *camera = mScene->mCameras.back();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
         // near and far clip plane
     case Discreet3DS::CHUNK_CAM_RANGES:
         camera->mClipPlaneNear = stream->GetF4();
-        camera->mClipPlaneFar  = stream->GetF4();
+        camera->mClipPlaneFar = stream->GetF4();
         break;
     }
 
@@ -550,13 +518,11 @@ void Discreet3DSImporter::ParseCameraChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseKeyframeChunk()
-{
+void Discreet3DSImporter::ParseKeyframeChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_TRACKCAMTGT:
     case Discreet3DS::CHUNK_TRACKSPOTL:
     case Discreet3DS::CHUNK_TRACKCAMERA:
@@ -574,31 +540,30 @@ void Discreet3DSImporter::ParseKeyframeChunk()
 
 // ------------------------------------------------------------------------------------------------
 // Little helper function for ParseHierarchyChunk
-void Discreet3DSImporter::InverseNodeSearch(D3DS::Node* pcNode,D3DS::Node* pcCurrent)
-{
+void Discreet3DSImporter::InverseNodeSearch(D3DS::Node *pcNode, D3DS::Node *pcCurrent) {
     if (!pcCurrent) {
         mRootNode->push_back(pcNode);
         return;
     }
 
-    if (pcCurrent->mHierarchyPos == pcNode->mHierarchyPos)  {
-        if(pcCurrent->mParent) {
+    if (pcCurrent->mHierarchyPos == pcNode->mHierarchyPos) {
+        if (pcCurrent->mParent) {
             pcCurrent->mParent->push_back(pcNode);
-        }
-        else pcCurrent->push_back(pcNode);
+        } else
+            pcCurrent->push_back(pcNode);
         return;
     }
-    return InverseNodeSearch(pcNode,pcCurrent->mParent);
+    return InverseNodeSearch(pcNode, pcCurrent->mParent);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Find a node with a specific name in the import hierarchy
-D3DS::Node* FindNode(D3DS::Node* root, const std::string& name) {
+D3DS::Node *FindNode(D3DS::Node *root, const std::string &name) {
     if (root->mName == name) {
         return root;
     }
 
-    for (std::vector<D3DS::Node*>::iterator it = root->mChildren.begin();it != root->mChildren.end(); ++it) {
+    for (std::vector<D3DS::Node *>::iterator it = root->mChildren.begin(); it != root->mChildren.end(); ++it) {
         D3DS::Node *nd = FindNode(*it, name);
         if (nullptr != nd) {
             return nd;
@@ -611,15 +576,13 @@ D3DS::Node* FindNode(D3DS::Node* root, const std::string& name) {
 // ------------------------------------------------------------------------------------------------
 // Binary predicate for std::unique()
 template <class T>
-bool KeyUniqueCompare(const T& first, const T& second)
-{
+bool KeyUniqueCompare(const T &first, const T &second) {
     return first.mTime == second.mTime;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Skip some additional import data.
-void Discreet3DSImporter::SkipTCBInfo()
-{
+void Discreet3DSImporter::SkipTCBInfo() {
     unsigned int flags = stream->GetI2();
 
     if (!flags) {
@@ -649,73 +612,68 @@ void Discreet3DSImporter::SkipTCBInfo()
 
 // ------------------------------------------------------------------------------------------------
 // Read hierarchy and keyframe info
-void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
-{
+void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent) {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_TRACKOBJNAME:
 
         // This is the name of the object to which the track applies. The chunk also
         // defines the position of this object in the hierarchy.
         {
 
-        // First of all: get the name of the object
-        unsigned int cnt = 0;
-        const char* sz = (const char*)stream->GetPtr();
+            // First of all: get the name of the object
+            unsigned int cnt = 0;
+            const char *sz = (const char *)stream->GetPtr();
 
-        while (stream->GetI1())++cnt;
-        std::string name = std::string(sz,cnt);
+            while (stream->GetI1())
+                ++cnt;
+            std::string name = std::string(sz, cnt);
 
-        // Now find out whether we have this node already (target animation channels
-        // are stored with a separate object ID)
-        D3DS::Node* pcNode = FindNode(mRootNode,name);
-        int instanceNumber = 1;
+            // Now find out whether we have this node already (target animation channels
+            // are stored with a separate object ID)
+            D3DS::Node *pcNode = FindNode(mRootNode, name);
+            int instanceNumber = 1;
 
-        if ( pcNode)
-        {
-            // if the source is not a CHUNK_TRACKINFO block it won't be an object instance
-            if (parent != Discreet3DS::CHUNK_TRACKINFO)
-            {
-                mCurrentNode = pcNode;
-                break;
+            if (pcNode) {
+                // if the source is not a CHUNK_TRACKINFO block it won't be an object instance
+                if (parent != Discreet3DS::CHUNK_TRACKINFO) {
+                    mCurrentNode = pcNode;
+                    break;
+                }
+                pcNode->mInstanceCount++;
+                instanceNumber = pcNode->mInstanceCount;
             }
-            pcNode->mInstanceCount++;
-            instanceNumber = pcNode->mInstanceCount;
-        }
-        pcNode = new D3DS::Node(name);
-        pcNode->mInstanceNumber = instanceNumber;
+            pcNode = new D3DS::Node(name);
+            pcNode->mInstanceNumber = instanceNumber;
 
-        // There are two unknown values which we can safely ignore
-        stream->IncPtr(4);
+            // There are two unknown values which we can safely ignore
+            stream->IncPtr(4);
 
-        // Now read the hierarchy position of the object
-        uint16_t hierarchy = stream->GetI2() + 1;
-        pcNode->mHierarchyPos   = hierarchy;
-        pcNode->mHierarchyIndex = mLastNodeIndex;
+            // Now read the hierarchy position of the object
+            uint16_t hierarchy = stream->GetI2() + 1;
+            pcNode->mHierarchyPos = hierarchy;
+            pcNode->mHierarchyIndex = mLastNodeIndex;
 
-        // And find a proper position in the graph for it
-        if (mCurrentNode && mCurrentNode->mHierarchyPos == hierarchy)   {
+            // And find a proper position in the graph for it
+            if (mCurrentNode && mCurrentNode->mHierarchyPos == hierarchy) {
 
-            // add to the parent of the last touched node
-            mCurrentNode->mParent->push_back(pcNode);
-            mLastNodeIndex++;
-        }
-        else if(hierarchy >= mLastNodeIndex)    {
+                // add to the parent of the last touched node
+                mCurrentNode->mParent->push_back(pcNode);
+                mLastNodeIndex++;
+            } else if (hierarchy >= mLastNodeIndex) {
 
-            // place it at the current position in the hierarchy
-            mCurrentNode->push_back(pcNode);
-            mLastNodeIndex = hierarchy;
-        }
-        else    {
-            // need to go back to the specified position in the hierarchy.
-            InverseNodeSearch(pcNode,mCurrentNode);
-            mLastNodeIndex++;
-        }
-        // Make this node the current node
-        mCurrentNode = pcNode;
+                // place it at the current position in the hierarchy
+                mCurrentNode->push_back(pcNode);
+                mLastNodeIndex = hierarchy;
+            } else {
+                // need to go back to the specified position in the hierarchy.
+                InverseNodeSearch(pcNode, mCurrentNode);
+                mLastNodeIndex++;
+            }
+            // Make this node the current node
+            mCurrentNode = pcNode;
         }
         break;
 
@@ -723,11 +681,12 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
         // This is the "real" name of a $$$DUMMY object
         {
-            const char* sz = (const char*) stream->GetPtr();
-            while (stream->GetI1());
+            const char *sz = (const char *)stream->GetPtr();
+            while (stream->GetI1())
+                ;
 
             // If object name is DUMMY, take this one instead
-            if (mCurrentNode->mName == "$$$DUMMY")  {
+            if (mCurrentNode->mName == "$$$DUMMY") {
                 mCurrentNode->mName = std::string(sz);
                 break;
             }
@@ -736,8 +695,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
     case Discreet3DS::CHUNK_TRACKPIVOT:
 
-        if ( Discreet3DS::CHUNK_TRACKINFO != parent)
-        {
+        if (Discreet3DS::CHUNK_TRACKINFO != parent) {
             ASSIMP_LOG_WARN("3DS: Skipping pivot subchunk for non usual object");
             break;
         }
@@ -748,25 +706,23 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
         mCurrentNode->vPivot.z = stream->GetF4();
         break;
 
-
         // ////////////////////////////////////////////////////////////////////
         // POSITION KEYFRAME
-    case Discreet3DS::CHUNK_TRACKPOS:
-        {
+    case Discreet3DS::CHUNK_TRACKPOS: {
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI4();
         bool sortKeys = false;
 
         // This could also be meant as the target position for
         // (targeted) lights and cameras
-        std::vector<aiVectorKey>* l;
-        if ( Discreet3DS::CHUNK_TRACKCAMTGT == parent || Discreet3DS::CHUNK_TRACKLIGTGT == parent)  {
-            l = & mCurrentNode->aTargetPositionKeys;
-        }
-        else l = & mCurrentNode->aPositionKeys;
+        std::vector<aiVectorKey> *l;
+        if (Discreet3DS::CHUNK_TRACKCAMTGT == parent || Discreet3DS::CHUNK_TRACKLIGTGT == parent) {
+            l = &mCurrentNode->aTargetPositionKeys;
+        } else
+            l = &mCurrentNode->aPositionKeys;
 
         l->reserve(numFrames);
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
 
             // Setup a new position key
@@ -787,29 +743,29 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
         }
 
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiVectorKey>), l->end() );
-        }}
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiVectorKey>), l->end());
+        }
+    }
 
-        break;
+    break;
 
         // ////////////////////////////////////////////////////////////////////
         // CAMERA ROLL KEYFRAME
-    case Discreet3DS::CHUNK_TRACKROLL:
-        {
+    case Discreet3DS::CHUNK_TRACKROLL: {
         // roll keys are accepted for cameras only
-        if (parent != Discreet3DS::CHUNK_TRACKCAMERA)   {
+        if (parent != Discreet3DS::CHUNK_TRACKCAMERA) {
             ASSIMP_LOG_WARN("3DS: Ignoring roll track for non-camera object");
             break;
         }
         bool sortKeys = false;
-        std::vector<aiFloatKey>* l = &mCurrentNode->aCameraRollKeys;
+        std::vector<aiFloatKey> *l = &mCurrentNode->aCameraRollKeys;
 
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI4();
         l->reserve(numFrames);
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
 
             // Setup a new position key
@@ -829,35 +785,30 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
         }
 
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiFloatKey>), l->end() );
-        }}
-        break;
-
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiFloatKey>), l->end());
+        }
+    } break;
 
         // ////////////////////////////////////////////////////////////////////
         // CAMERA FOV KEYFRAME
-    case Discreet3DS::CHUNK_TRACKFOV:
-        {
-            ASSIMP_LOG_ERROR("3DS: Skipping FOV animation track. "
-                "This is not supported");
-        }
-        break;
-
+    case Discreet3DS::CHUNK_TRACKFOV: {
+        ASSIMP_LOG_ERROR("3DS: Skipping FOV animation track. "
+                         "This is not supported");
+    } break;
 
         // ////////////////////////////////////////////////////////////////////
         // ROTATION KEYFRAME
-    case Discreet3DS::CHUNK_TRACKROTATE:
-        {
+    case Discreet3DS::CHUNK_TRACKROTATE: {
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI4();
 
         bool sortKeys = false;
-        std::vector<aiQuatKey>* l = &mCurrentNode->aRotationKeys;
+        std::vector<aiQuatKey> *l = &mCurrentNode->aRotationKeys;
         l->reserve(numFrames);
 
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
             SkipTCBInfo();
 
@@ -875,7 +826,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
                 axis.y = 1.f;
 
             // Construct a rotation quaternion from the axis-angle pair
-            v.mValue = aiQuaternion(axis,rad);
+            v.mValue = aiQuaternion(axis, rad);
 
             // Check whether we'll need to sort the keys
             if (!l->empty() && v.mTime <= l->back().mTime)
@@ -885,25 +836,24 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
             l->push_back(v);
         }
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiQuatKey>), l->end() );
-        }}
-        break;
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiQuatKey>), l->end());
+        }
+    } break;
 
         // ////////////////////////////////////////////////////////////////////
         // SCALING KEYFRAME
-    case Discreet3DS::CHUNK_TRACKSCALE:
-        {
+    case Discreet3DS::CHUNK_TRACKSCALE: {
         stream->IncPtr(10);
         const unsigned int numFrames = stream->GetI2();
         stream->IncPtr(2);
 
         bool sortKeys = false;
-        std::vector<aiVectorKey>* l = &mCurrentNode->aScalingKeys;
+        std::vector<aiVectorKey> *l = &mCurrentNode->aScalingKeys;
         l->reserve(numFrames);
 
-        for (unsigned int i = 0; i < numFrames;++i) {
+        for (unsigned int i = 0; i < numFrames; ++i) {
             const unsigned int fidx = stream->GetI4();
             SkipTCBInfo();
 
@@ -928,11 +878,11 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
             l->push_back(v);
         }
         // Sort all keys with ascending time values and remove duplicates?
-        if (sortKeys)   {
-            std::stable_sort(l->begin(),l->end());
-            l->erase ( std::unique (l->begin(),l->end(),&KeyUniqueCompare<aiVectorKey>), l->end() );
-        }}
-        break;
+        if (sortKeys) {
+            std::stable_sort(l->begin(), l->end());
+            l->erase(std::unique(l->begin(), l->end(), &KeyUniqueCompare<aiVectorKey>), l->end());
+        }
+    } break;
     };
 
     ASSIMP_3DS_END_CHUNK();
@@ -940,92 +890,85 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
 // ------------------------------------------------------------------------------------------------
 // Read a face chunk - it contains smoothing groups and material assignments
-void Discreet3DSImporter::ParseFaceChunk()
-{
+void Discreet3DSImporter::ParseFaceChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // Get the mesh we're currently working on
-    D3DS::Mesh& mMesh = mScene->mMeshes.back();
+    D3DS::Mesh &mMesh = mScene->mMeshes.back();
 
     // Get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_SMOOLIST:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_SMOOLIST: {
         // This is the list of smoothing groups - a bitfield for every face.
         // Up to 32 smoothing groups assigned to a single face.
-        unsigned int num = chunkSize/4, m = 0;
-        if (num > mMesh.mFaces.size())  {
+        unsigned int num = chunkSize / 4, m = 0;
+        if (num > mMesh.mFaces.size()) {
             throw DeadlyImportError("3DS: More smoothing groups than faces");
         }
-        for (std::vector<D3DS::Face>::iterator i =  mMesh.mFaces.begin(); m != num;++i, ++m)    {
+        for (std::vector<D3DS::Face>::iterator i = mMesh.mFaces.begin(); m != num; ++i, ++m) {
             // nth bit is set for nth smoothing group
             (*i).iSmoothGroup = stream->GetI4();
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_FACEMAT:
-        {
+    case Discreet3DS::CHUNK_FACEMAT: {
         // at fist an asciiz with the material name
-        const char* sz = (const char*)stream->GetPtr();
-        while (stream->GetI1());
+        const char *sz = (const char *)stream->GetPtr();
+        while (stream->GetI1())
+            ;
 
         // find the index of the material
         unsigned int idx = 0xcdcdcdcd, cnt = 0;
-        for (std::vector<D3DS::Material>::const_iterator i =  mScene->mMaterials.begin();i != mScene->mMaterials.end();++i,++cnt)   {
+        for (std::vector<D3DS::Material>::const_iterator i = mScene->mMaterials.begin(); i != mScene->mMaterials.end(); ++i, ++cnt) {
             // use case independent comparisons. hopefully it will work.
             if ((*i).mName.length() && !ASSIMP_stricmp(sz, (*i).mName.c_str())) {
                 idx = cnt;
                 break;
             }
         }
-        if (0xcdcdcdcd == idx)  {
-            ASSIMP_LOG_ERROR_F( "3DS: Unknown material: ", sz);
+        if (0xcdcdcdcd == idx) {
+            ASSIMP_LOG_ERROR_F("3DS: Unknown material: ", sz);
         }
 
         // Now continue and read all material indices
         cnt = (uint16_t)stream->GetI2();
-        for (unsigned int i = 0; i < cnt;++i)   {
+        for (unsigned int i = 0; i < cnt; ++i) {
             unsigned int fidx = (uint16_t)stream->GetI2();
 
             // check range
-            if (fidx >= mMesh.mFaceMaterials.size())    {
+            if (fidx >= mMesh.mFaceMaterials.size()) {
                 ASSIMP_LOG_ERROR("3DS: Invalid face index in face material list");
-            }
-            else mMesh.mFaceMaterials[fidx] = idx;
-        }}
-        break;
+            } else
+                mMesh.mFaceMaterials[fidx] = idx;
+        }
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a mesh chunk. Here's the actual mesh data
-void Discreet3DSImporter::ParseMeshChunk()
-{
+void Discreet3DSImporter::ParseMeshChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // Get the mesh we're currently working on
-    D3DS::Mesh& mMesh = mScene->mMeshes.back();
+    D3DS::Mesh &mMesh = mScene->mMeshes.back();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_VERTLIST:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_VERTLIST: {
         // This is the list of all vertices in the current mesh
         int num = (int)(uint16_t)stream->GetI2();
         mMesh.mPositions.reserve(num);
-        while (num-- > 0)   {
+        while (num-- > 0) {
             aiVector3D v;
             v.x = stream->GetF4();
             v.y = stream->GetF4();
             v.z = stream->GetF4();
             mMesh.mPositions.push_back(v);
-        }}
-        break;
-    case Discreet3DS::CHUNK_TRMATRIX:
-        {
+        }
+    } break;
+    case Discreet3DS::CHUNK_TRMATRIX: {
         // This is the RLEATIVE transformation matrix of the current mesh. Vertices are
         // pretransformed by this matrix wonder.
         mMesh.mMat.a1 = stream->GetF4();
@@ -1040,31 +983,28 @@ void Discreet3DSImporter::ParseMeshChunk()
         mMesh.mMat.a4 = stream->GetF4();
         mMesh.mMat.b4 = stream->GetF4();
         mMesh.mMat.c4 = stream->GetF4();
-        }
-        break;
+    } break;
 
-    case Discreet3DS::CHUNK_MAPLIST:
-        {
+    case Discreet3DS::CHUNK_MAPLIST: {
         // This is the list of all UV coords in the current mesh
         int num = (int)(uint16_t)stream->GetI2();
         mMesh.mTexCoords.reserve(num);
-        while (num-- > 0)   {
+        while (num-- > 0) {
             aiVector3D v;
             v.x = stream->GetF4();
             v.y = stream->GetF4();
             mMesh.mTexCoords.push_back(v);
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_FACELIST:
-        {
+    case Discreet3DS::CHUNK_FACELIST: {
         // This is the list of all faces in the current mesh
         int num = (int)(uint16_t)stream->GetI2();
         mMesh.mFaces.reserve(num);
-        while (num-- > 0)   {
+        while (num-- > 0) {
             // 3DS faces are ALWAYS triangles
             mMesh.mFaces.push_back(D3DS::Face());
-            D3DS::Face& sFace = mMesh.mFaces.back();
+            D3DS::Face &sFace = mMesh.mFaces.back();
 
             sFace.mIndices[0] = (uint16_t)stream->GetI2();
             sFace.mIndices[1] = (uint16_t)stream->GetI2();
@@ -1075,103 +1015,93 @@ void Discreet3DSImporter::ParseMeshChunk()
 
         // Resize the material array (0xcdcdcdcd marks the default material; so if a face is
         // not referenced by a material, $$DEFAULT will be assigned to it)
-        mMesh.mFaceMaterials.resize(mMesh.mFaces.size(),0xcdcdcdcd);
+        mMesh.mFaceMaterials.resize(mMesh.mFaces.size(), 0xcdcdcdcd);
 
         // Larger 3DS files could have multiple FACE chunks here
         chunkSize = (int)stream->GetRemainingSizeToLimit();
-        if ( chunkSize > (int) sizeof(Discreet3DS::Chunk ) )
+        if (chunkSize > (int)sizeof(Discreet3DS::Chunk))
             ParseFaceChunk();
-        }
-        break;
+    } break;
     };
     ASSIMP_3DS_END_CHUNK();
 }
 
 // ------------------------------------------------------------------------------------------------
 // Read a 3DS material chunk
-void Discreet3DSImporter::ParseMaterialChunk()
-{
+void Discreet3DSImporter::ParseMaterialChunk() {
     ASSIMP_3DS_BEGIN_CHUNK();
-    switch (chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_MAT_MATNAME:
 
-        {
+    {
         // The material name string is already zero-terminated, but we need to be sure ...
-        const char* sz = (const char*)stream->GetPtr();
+        const char *sz = (const char *)stream->GetPtr();
         unsigned int cnt = 0;
         while (stream->GetI1())
             ++cnt;
 
-        if (!cnt)   {
+        if (!cnt) {
             // This may not be, we use the default name instead
             ASSIMP_LOG_ERROR("3DS: Empty material name");
-        }
-        else mScene->mMaterials.back().mName = std::string(sz,cnt);
-        }
-        break;
+        } else
+            mScene->mMaterials.back().mName = std::string(sz, cnt);
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_DIFFUSE:
-        {
+    case Discreet3DS::CHUNK_MAT_DIFFUSE: {
         // This is the diffuse material color
-        aiColor3D* pc = &mScene->mMaterials.back().mDiffuse;
+        aiColor3D *pc = &mScene->mMaterials.back().mDiffuse;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read DIFFUSE chunk");
             pc->r = pc->g = pc->b = 1.0f;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SPECULAR:
-        {
+    case Discreet3DS::CHUNK_MAT_SPECULAR: {
         // This is the specular material color
-        aiColor3D* pc = &mScene->mMaterials.back().mSpecular;
+        aiColor3D *pc = &mScene->mMaterials.back().mSpecular;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read SPECULAR chunk");
             pc->r = pc->g = pc->b = 1.0f;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_AMBIENT:
-        {
+    case Discreet3DS::CHUNK_MAT_AMBIENT: {
         // This is the ambient material color
-        aiColor3D* pc = &mScene->mMaterials.back().mAmbient;
+        aiColor3D *pc = &mScene->mMaterials.back().mAmbient;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read AMBIENT chunk");
             pc->r = pc->g = pc->b = 0.0f;
-        }}
-        break;
+        }
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SELF_ILLUM:
-        {
+    case Discreet3DS::CHUNK_MAT_SELF_ILLUM: {
         // This is the emissive material color
-        aiColor3D* pc = &mScene->mMaterials.back().mEmissive;
+        aiColor3D *pc = &mScene->mMaterials.back().mEmissive;
         ParseColorChunk(pc);
         if (is_qnan(pc->r)) {
             // color chunk is invalid. Simply ignore it
             ASSIMP_LOG_ERROR("3DS: Unable to read EMISSIVE chunk");
             pc->r = pc->g = pc->b = 0.0f;
-        }}
-        break;
-
-    case Discreet3DS::CHUNK_MAT_TRANSPARENCY:
-        {
-            // This is the material's transparency
-            ai_real* pcf = &mScene->mMaterials.back().mTransparency;
-            *pcf = ParsePercentageChunk();
-
-            // NOTE: transparency, not opacity
-            if (is_qnan(*pcf))
-                *pcf = ai_real( 1.0 );
-            else 
-                *pcf = ai_real( 1.0 ) - *pcf * (ai_real)0xFFFF / ai_real( 100.0 );
         }
-        break;
+    } break;
+
+    case Discreet3DS::CHUNK_MAT_TRANSPARENCY: {
+        // This is the material's transparency
+        ai_real *pcf = &mScene->mMaterials.back().mTransparency;
+        *pcf = ParsePercentageChunk();
+
+        // NOTE: transparency, not opacity
+        if (is_qnan(*pcf))
+            *pcf = ai_real(1.0);
+        else
+            *pcf = ai_real(1.0) - *pcf * (ai_real)0xFFFF / ai_real(100.0);
+    } break;
 
     case Discreet3DS::CHUNK_MAT_SHADING:
         // This is the material shading mode
@@ -1183,37 +1113,32 @@ void Discreet3DSImporter::ParseMaterialChunk()
         mScene->mMaterials.back().mTwoSided = true;
         break;
 
-    case Discreet3DS::CHUNK_MAT_SHININESS:
-        { // This is the shininess of the material
-        ai_real* pcf = &mScene->mMaterials.back().mSpecularExponent;
+    case Discreet3DS::CHUNK_MAT_SHININESS: { // This is the shininess of the material
+        ai_real *pcf = &mScene->mMaterials.back().mSpecularExponent;
         *pcf = ParsePercentageChunk();
         if (is_qnan(*pcf))
             *pcf = 0.0;
-        else *pcf *= (ai_real)0xFFFF;
-        }
-        break;
+        else
+            *pcf *= (ai_real)0xFFFF;
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT:
-        { // This is the shininess strength of the material
-            ai_real* pcf = &mScene->mMaterials.back().mShininessStrength;
-            *pcf = ParsePercentageChunk();
-            if (is_qnan(*pcf))
-                *pcf = ai_real( 0.0 );
-            else 
-                *pcf *= (ai_real)0xffff / ai_real( 100.0 );
-        }
-        break;
+    case Discreet3DS::CHUNK_MAT_SHININESS_PERCENT: { // This is the shininess strength of the material
+        ai_real *pcf = &mScene->mMaterials.back().mShininessStrength;
+        *pcf = ParsePercentageChunk();
+        if (is_qnan(*pcf))
+            *pcf = ai_real(0.0);
+        else
+            *pcf *= (ai_real)0xffff / ai_real(100.0);
+    } break;
 
-    case Discreet3DS::CHUNK_MAT_SELF_ILPCT:
-        { // This is the self illumination strength of the material
-            ai_real f = ParsePercentageChunk();
-            if (is_qnan(f))
-                f = ai_real( 0.0 );
-            else 
-                f *= (ai_real)0xFFFF / ai_real( 100.0 );
-            mScene->mMaterials.back().mEmissive = aiColor3D(f,f,f);
-        }
-        break;
+    case Discreet3DS::CHUNK_MAT_SELF_ILPCT: { // This is the self illumination strength of the material
+        ai_real f = ParsePercentageChunk();
+        if (is_qnan(f))
+            f = ai_real(0.0);
+        else
+            f *= (ai_real)0xFFFF / ai_real(100.0);
+        mScene->mMaterials.back().mEmissive = aiColor3D(f, f, f);
+    } break;
 
     // Parse texture chunks
     case Discreet3DS::CHUNK_MAT_TEXTURE:
@@ -1249,28 +1174,23 @@ void Discreet3DSImporter::ParseMaterialChunk()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
-{
+void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture *pcOut) {
     ASSIMP_3DS_BEGIN_CHUNK();
 
     // get chunk type
-    switch (chunk.Flag)
-    {
-    case Discreet3DS::CHUNK_MAPFILE:
-        {
+    switch (chunk.Flag) {
+    case Discreet3DS::CHUNK_MAPFILE: {
         // The material name string is already zero-terminated, but we need to be sure ...
-        const char* sz = (const char*)stream->GetPtr();
+        const char *sz = (const char *)stream->GetPtr();
         unsigned int cnt = 0;
         while (stream->GetI1())
             ++cnt;
-        pcOut->mMapName = std::string(sz,cnt);
-        }
-        break;
-
+        pcOut->mMapName = std::string(sz, cnt);
+    } break;
 
     case Discreet3DS::CHUNK_PERCENTD:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = ai_real( stream->GetF8() );
+        pcOut->mTextureBlend = ai_real(stream->GetF8());
         break;
 
     case Discreet3DS::CHUNK_PERCENTF:
@@ -1280,14 +1200,13 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
 
     case Discreet3DS::CHUNK_PERCENTW:
         // Manually parse the blend factor
-        pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / ai_real( 100.0 );
+        pcOut->mTextureBlend = (ai_real)((uint16_t)stream->GetI2()) / ai_real(100.0);
         break;
 
     case Discreet3DS::CHUNK_MAT_MAP_USCALE:
         // Texture coordinate scaling in the U direction
         pcOut->mScaleU = stream->GetF4();
-        if (0.0f == pcOut->mScaleU)
-        {
+        if (0.0f == pcOut->mScaleU) {
             ASSIMP_LOG_WARN("Texture coordinate scaling in the x direction is zero. Assuming 1.");
             pcOut->mScaleU = 1.0f;
         }
@@ -1295,8 +1214,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
     case Discreet3DS::CHUNK_MAT_MAP_VSCALE:
         // Texture coordinate scaling in the V direction
         pcOut->mScaleV = stream->GetF4();
-        if (0.0f == pcOut->mScaleV)
-        {
+        if (0.0f == pcOut->mScaleV) {
             ASSIMP_LOG_WARN("Texture coordinate scaling in the y direction is zero. Assuming 1.");
             pcOut->mScaleV = 1.0f;
         }
@@ -1314,11 +1232,10 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
 
     case Discreet3DS::CHUNK_MAT_MAP_ANG:
         // Texture coordinate rotation, CCW in DEGREES
-        pcOut->mRotation = -AI_DEG_TO_RAD( stream->GetF4() );
+        pcOut->mRotation = -AI_DEG_TO_RAD(stream->GetF4());
         break;
 
-    case Discreet3DS::CHUNK_MAT_MAP_TILING:
-        {
+    case Discreet3DS::CHUNK_MAT_MAP_TILING: {
         const uint16_t iFlags = stream->GetI2();
 
         // Get the mapping mode (for both axes)
@@ -1329,9 +1246,9 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
             pcOut->mMapMode = aiTextureMapMode_Decal;
 
         // wrapping in all remaining cases
-        else pcOut->mMapMode = aiTextureMapMode_Wrap;
-        }
-        break;
+        else
+            pcOut->mMapMode = aiTextureMapMode_Wrap;
+    } break;
     };
 
     ASSIMP_3DS_END_CHUNK();
@@ -1354,13 +1271,12 @@ ai_real Discreet3DSImporter::ParsePercentageChunk() {
 
 // ------------------------------------------------------------------------------------------------
 // Read a color chunk. If a percentage chunk is found instead it is read as a grayscale color
-void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
-{
-    ai_assert(out != NULL);
+void Discreet3DSImporter::ParseColorChunk(aiColor3D *out, bool acceptPercent) {
+    ai_assert(out != nullptr);
 
     // error return value
     const ai_real qnan = get_qnan();
-    static const aiColor3D clrError = aiColor3D(qnan,qnan,qnan);
+    static const aiColor3D clrError = aiColor3D(qnan, qnan, qnan);
 
     Discreet3DS::Chunk chunk;
     ReadChunk(&chunk);
@@ -1369,13 +1285,12 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
     bool bGamma = false;
 
     // Get the type of the chunk
-    switch(chunk.Flag)
-    {
+    switch (chunk.Flag) {
     case Discreet3DS::CHUNK_LINRGBF:
         bGamma = true;
 
     case Discreet3DS::CHUNK_RGBF:
-        if (sizeof(float) * 3 > diff)   {
+        if (sizeof(float) * 3 > diff) {
             *out = clrError;
             return;
         }
@@ -1386,18 +1301,16 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
 
     case Discreet3DS::CHUNK_LINRGBB:
         bGamma = true;
-    case Discreet3DS::CHUNK_RGBB:
-        {
-            if ( sizeof( char ) * 3 > diff ) {
-                *out = clrError;
-                return;
-            }
-            const ai_real invVal = ai_real( 1.0 ) / ai_real( 255.0 );
-            out->r = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
-            out->g = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
-            out->b = ( ai_real ) ( uint8_t ) stream->GetI1() * invVal;
+    case Discreet3DS::CHUNK_RGBB: {
+        if (sizeof(char) * 3 > diff) {
+            *out = clrError;
+            return;
         }
-        break;
+        const ai_real invVal = ai_real(1.0) / ai_real(255.0);
+        out->r = (ai_real)(uint8_t)stream->GetI1() * invVal;
+        out->g = (ai_real)(uint8_t)stream->GetI1() * invVal;
+        out->b = (ai_real)(uint8_t)stream->GetI1() * invVal;
+    } break;
 
     // Percentage chunks are accepted, too.
     case Discreet3DS::CHUNK_PERCENTF:
@@ -1410,7 +1323,7 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
 
     case Discreet3DS::CHUNK_PERCENTW:
         if (acceptPercent && 1 <= diff) {
-            out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / ai_real( 255.0 );
+            out->g = out->b = out->r = (ai_real)(uint8_t)stream->GetI1() / ai_real(255.0);
             break;
         }
         *out = clrError;
@@ -1419,7 +1332,7 @@ void Discreet3DSImporter::ParseColorChunk( aiColor3D* out, bool acceptPercent )
     default:
         stream->IncPtr(diff);
         // Skip unknown chunks, hope this won't cause any problems.
-        return ParseColorChunk(out,acceptPercent);
+        return ParseColorChunk(out, acceptPercent);
     };
     (void)bGamma;
 }
diff --git a/code/3DS/3DSLoader.h b/code/AssetLib/3DS/3DSLoader.h
similarity index 100%
rename from code/3DS/3DSLoader.h
rename to code/AssetLib/3DS/3DSLoader.h
diff --git a/code/3MF/3MFXmlTags.h b/code/AssetLib/3MF/3MFXmlTags.h
similarity index 100%
rename from code/3MF/3MFXmlTags.h
rename to code/AssetLib/3MF/3MFXmlTags.h
diff --git a/code/3MF/D3MFExporter.cpp b/code/AssetLib/3MF/D3MFExporter.cpp
similarity index 55%
rename from code/3MF/D3MFExporter.cpp
rename to code/AssetLib/3MF/D3MFExporter.cpp
index 83036b236..5b85d275b 100644
--- a/code/3MF/D3MFExporter.cpp
+++ b/code/AssetLib/3MF/D3MFExporter.cpp
@@ -44,81 +44,74 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "D3MFExporter.h"
 
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/IOStream.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/StringUtils.h>
 #include <assimp/Exceptional.h>
+#include <assimp/StringUtils.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include "3MFXmlTags.h"
 #include "D3MFOpcPackage.h"
 
 #ifdef ASSIMP_USE_HUNTER
-#  include <zip/zip.h>
+#include <zip/zip.h>
 #else
-#  include <contrib/zip/src/zip.h>
+#include <contrib/zip/src/zip.h>
 #endif
 
 namespace Assimp {
 
-void ExportScene3MF( const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/ ) {
-    if ( nullptr == pIOSystem ) {
-        throw DeadlyExportError( "Could not export 3MP archive: " + std::string( pFile ) );
+void ExportScene3MF(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    if (nullptr == pIOSystem) {
+        throw DeadlyExportError("Could not export 3MP archive: " + std::string(pFile));
     }
-    D3MF::D3MFExporter myExporter( pFile, pScene );
-    if ( myExporter.validate() ) {
-        if ( pIOSystem->Exists( pFile ) ) {
-            if ( !pIOSystem->DeleteFile( pFile ) ) {
-                throw DeadlyExportError( "File exists, cannot override : " + std::string( pFile ) );
+    D3MF::D3MFExporter myExporter(pFile, pScene);
+    if (myExporter.validate()) {
+        if (pIOSystem->Exists(pFile)) {
+            if (!pIOSystem->DeleteFile(pFile)) {
+                throw DeadlyExportError("File exists, cannot override : " + std::string(pFile));
             }
         }
         bool ok = myExporter.exportArchive(pFile);
-        if ( !ok ) {
-            throw DeadlyExportError( "Could not export 3MP archive: " + std::string( pFile ) );
+        if (!ok) {
+            throw DeadlyExportError("Could not export 3MP archive: " + std::string(pFile));
         }
     }
 }
 
 namespace D3MF {
 
-D3MFExporter::D3MFExporter( const char* pFile, const aiScene* pScene )
-: mArchiveName( pFile )
-, m_zipArchive( nullptr )
-, mScene( pScene )
-, mModelOutput()
-, mRelOutput()
-, mContentOutput()
-, mBuildItems()
-, mRelations() {
+D3MFExporter::D3MFExporter(const char *pFile, const aiScene *pScene) :
+        mArchiveName(pFile), m_zipArchive(nullptr), mScene(pScene), mModelOutput(), mRelOutput(), mContentOutput(), mBuildItems(), mRelations() {
     // empty
 }
 
 D3MFExporter::~D3MFExporter() {
-    for ( size_t i = 0; i < mRelations.size(); ++i ) {
-        delete mRelations[ i ];
+    for (size_t i = 0; i < mRelations.size(); ++i) {
+        delete mRelations[i];
     }
     mRelations.clear();
 }
 
 bool D3MFExporter::validate() {
-    if ( mArchiveName.empty() ) {
+    if (mArchiveName.empty()) {
         return false;
     }
 
-    if ( nullptr == mScene ) {
+    if (nullptr == mScene) {
         return false;
     }
 
     return true;
 }
 
-bool D3MFExporter::exportArchive( const char *file ) {
-    bool ok( true );
+bool D3MFExporter::exportArchive(const char *file) {
+    bool ok(true);
 
-    m_zipArchive = zip_open( file, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w' );
-    if ( nullptr == m_zipArchive ) {
+    m_zipArchive = zip_open(file, ZIP_DEFAULT_COMPRESSION_LEVEL, 'w');
+    if (nullptr == m_zipArchive) {
         return false;
     }
 
@@ -126,7 +119,7 @@ bool D3MFExporter::exportArchive( const char *file ) {
     ok |= export3DModel();
     ok |= exportRelations();
 
-    zip_close( m_zipArchive );
+    zip_close(m_zipArchive);
     m_zipArchive = nullptr;
 
     return ok;
@@ -145,7 +138,7 @@ bool D3MFExporter::exportContentTypes() {
     mContentOutput << std::endl;
     mContentOutput << "</Types>";
     mContentOutput << std::endl;
-    exportContentTyp( XmlTag::CONTENT_TYPES_ARCHIVE );
+    exportContentTyp(XmlTag::CONTENT_TYPES_ARCHIVE);
 
     return true;
 }
@@ -157,20 +150,20 @@ bool D3MFExporter::exportRelations() {
     mRelOutput << std::endl;
     mRelOutput << "<Relationships xmlns=\"http://schemas.openxmlformats.org/package/2006/relationships\">";
 
-    for ( size_t i = 0; i < mRelations.size(); ++i ) {
-        if ( mRelations[ i ]->target[ 0 ] == '/' ) {
-            mRelOutput << "<Relationship Target=\"" << mRelations[ i ]->target << "\" ";
+    for (size_t i = 0; i < mRelations.size(); ++i) {
+        if (mRelations[i]->target[0] == '/') {
+            mRelOutput << "<Relationship Target=\"" << mRelations[i]->target << "\" ";
         } else {
-            mRelOutput << "<Relationship Target=\"/" << mRelations[ i ]->target << "\" ";
+            mRelOutput << "<Relationship Target=\"/" << mRelations[i]->target << "\" ";
         }
         mRelOutput << "Id=\"" << mRelations[i]->id << "\" ";
-        mRelOutput << "Type=\"" << mRelations[ i ]->type << "\" />";
+        mRelOutput << "Type=\"" << mRelations[i]->type << "\" />";
         mRelOutput << std::endl;
     }
     mRelOutput << "</Relationships>";
     mRelOutput << std::endl;
 
-    writeRelInfoToFile( "_rels", ".rels" );
+    writeRelInfoToFile("_rels", ".rels");
     mRelOutput.flush();
 
     return true;
@@ -181,8 +174,8 @@ bool D3MFExporter::export3DModel() {
 
     writeHeader();
     mModelOutput << "<" << XmlTag::model << " " << XmlTag::model_unit << "=\"millimeter\""
-            << " xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\">"
-            << std::endl;
+                 << " xmlns=\"http://schemas.microsoft.com/3dmanufacturing/core/2015/02\">"
+                 << std::endl;
     mModelOutput << "<" << XmlTag::resources << ">";
     mModelOutput << std::endl;
 
@@ -192,7 +185,6 @@ bool D3MFExporter::export3DModel() {
 
     writeObjects();
 
-
     mModelOutput << "</" << XmlTag::resources << ">";
     mModelOutput << std::endl;
     writeBuild();
@@ -203,9 +195,9 @@ bool D3MFExporter::export3DModel() {
     info->id = "rel0";
     info->target = "/3D/3DModel.model";
     info->type = XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
-    mRelations.push_back( info );
+    mRelations.push_back(info);
 
-    writeModelToArchive( "3D", "3DModel.model" );
+    writeModelToArchive("3D", "3DModel.model");
     mModelOutput.flush();
 
     return true;
@@ -217,22 +209,22 @@ void D3MFExporter::writeHeader() {
 }
 
 void D3MFExporter::writeMetaData() {
-    if ( nullptr == mScene->mMetaData ) {
+    if (nullptr == mScene->mMetaData) {
         return;
     }
 
-    const unsigned int numMetaEntries( mScene->mMetaData->mNumProperties );
-    if ( 0 == numMetaEntries ) {
+    const unsigned int numMetaEntries(mScene->mMetaData->mNumProperties);
+    if (0 == numMetaEntries) {
         return;
     }
 
-	const aiString *key = nullptr;
+    const aiString *key = nullptr;
     const aiMetadataEntry *entry(nullptr);
-    for ( size_t i = 0; i < numMetaEntries; ++i ) {
-        mScene->mMetaData->Get( i, key, entry );
-        std::string k( key->C_Str() );
+    for (size_t i = 0; i < numMetaEntries; ++i) {
+        mScene->mMetaData->Get(i, key, entry);
+        std::string k(key->C_Str());
         aiString value;
-        mScene->mMetaData->Get(  k, value );
+        mScene->mMetaData->Get(k, value);
         mModelOutput << "<" << XmlTag::meta << " " << XmlTag::meta_name << "=\"" << key->C_Str() << "\">";
         mModelOutput << value.C_Str();
         mModelOutput << "</" << XmlTag::meta << ">" << std::endl;
@@ -241,115 +233,114 @@ void D3MFExporter::writeMetaData() {
 
 void D3MFExporter::writeBaseMaterials() {
     mModelOutput << "<basematerials id=\"1\">\n";
-    std::string strName, hexDiffuseColor , tmp;
-    for ( size_t i = 0; i < mScene->mNumMaterials; ++i ) {
-        aiMaterial *mat = mScene->mMaterials[ i ];
+    std::string strName, hexDiffuseColor, tmp;
+    for (size_t i = 0; i < mScene->mNumMaterials; ++i) {
+        aiMaterial *mat = mScene->mMaterials[i];
         aiString name;
-        if ( mat->Get( AI_MATKEY_NAME, name ) != aiReturn_SUCCESS ) {
-            strName = "basemat_" + to_string( i );
+        if (mat->Get(AI_MATKEY_NAME, name) != aiReturn_SUCCESS) {
+            strName = "basemat_" + to_string(i);
         } else {
             strName = name.C_Str();
         }
         aiColor4D color;
-        if ( mat->Get( AI_MATKEY_COLOR_DIFFUSE, color ) == aiReturn_SUCCESS ) {
+        if (mat->Get(AI_MATKEY_COLOR_DIFFUSE, color) == aiReturn_SUCCESS) {
             hexDiffuseColor.clear();
             tmp.clear();
             // rgbs %
-    		if(color.r <= 1 && color.g <= 1 && color.b <= 1 && color.a <= 1){
-    	
-    			 hexDiffuseColor = Rgba2Hex(
-    			 	(int)((ai_real)color.r)*255,
-    			 	(int)((ai_real)color.g)*255,
-    			 	(int)((ai_real)color.b)*255,
-    			 	(int)((ai_real)color.a)*255,
-    			 	true
-    			 );
-    			 
-    		}else{
-    			hexDiffuseColor = "#";
-            	tmp = DecimalToHexa( (ai_real) color.r );
-            	hexDiffuseColor += tmp;
-            	tmp = DecimalToHexa((ai_real)color.g);
-            	hexDiffuseColor += tmp;
-            	tmp = DecimalToHexa((ai_real)color.b);
-            	hexDiffuseColor += tmp;
-            	tmp = DecimalToHexa((ai_real)color.a);
-            	hexDiffuseColor += tmp;
-    		}
+            if (color.r <= 1 && color.g <= 1 && color.b <= 1 && color.a <= 1) {
+
+                hexDiffuseColor = Rgba2Hex(
+                        (int)((ai_real)color.r) * 255,
+                        (int)((ai_real)color.g) * 255,
+                        (int)((ai_real)color.b) * 255,
+                        (int)((ai_real)color.a) * 255,
+                        true);
+
+            } else {
+                hexDiffuseColor = "#";
+                tmp = DecimalToHexa((ai_real)color.r);
+                hexDiffuseColor += tmp;
+                tmp = DecimalToHexa((ai_real)color.g);
+                hexDiffuseColor += tmp;
+                tmp = DecimalToHexa((ai_real)color.b);
+                hexDiffuseColor += tmp;
+                tmp = DecimalToHexa((ai_real)color.a);
+                hexDiffuseColor += tmp;
+            }
         } else {
             hexDiffuseColor = "#FFFFFFFF";
         }
 
-        mModelOutput << "<base name=\""+strName+"\" "+" displaycolor=\""+hexDiffuseColor+"\" />\n";
+        mModelOutput << "<base name=\"" + strName + "\" " + " displaycolor=\"" + hexDiffuseColor + "\" />\n";
     }
     mModelOutput << "</basematerials>\n";
 }
 
 void D3MFExporter::writeObjects() {
-    if ( nullptr == mScene->mRootNode ) {
+    if (nullptr == mScene->mRootNode) {
         return;
     }
 
     aiNode *root = mScene->mRootNode;
-    for ( unsigned int i = 0; i < root->mNumChildren; ++i ) {
-        aiNode *currentNode( root->mChildren[ i ] );
-        if ( nullptr == currentNode ) {
+    for (unsigned int i = 0; i < root->mNumChildren; ++i) {
+        aiNode *currentNode(root->mChildren[i]);
+        if (nullptr == currentNode) {
             continue;
         }
         mModelOutput << "<" << XmlTag::object << " id=\"" << i + 2 << "\" type=\"model\">";
         mModelOutput << std::endl;
-        for ( unsigned int j = 0; j < currentNode->mNumMeshes; ++j ) {
-            aiMesh *currentMesh = mScene->mMeshes[ currentNode->mMeshes[ j ] ];
-            if ( nullptr == currentMesh ) {
+        for (unsigned int j = 0; j < currentNode->mNumMeshes; ++j) {
+            aiMesh *currentMesh = mScene->mMeshes[currentNode->mMeshes[j]];
+            if (nullptr == currentMesh) {
                 continue;
             }
-            writeMesh( currentMesh );
+            writeMesh(currentMesh);
         }
-        mBuildItems.push_back( i );
+        mBuildItems.push_back(i);
 
         mModelOutput << "</" << XmlTag::object << ">";
         mModelOutput << std::endl;
     }
 }
 
-void D3MFExporter::writeMesh( aiMesh *mesh ) {
-    if ( nullptr == mesh ) {
+void D3MFExporter::writeMesh(aiMesh *mesh) {
+    if (nullptr == mesh) {
         return;
     }
 
     mModelOutput << "<" << XmlTag::mesh << ">" << std::endl;
     mModelOutput << "<" << XmlTag::vertices << ">" << std::endl;
-    for ( unsigned int i = 0; i < mesh->mNumVertices; ++i ) {
-        writeVertex( mesh->mVertices[ i ] );
+    for (unsigned int i = 0; i < mesh->mNumVertices; ++i) {
+        writeVertex(mesh->mVertices[i]);
     }
     mModelOutput << "</" << XmlTag::vertices << ">" << std::endl;
 
-    const unsigned int matIdx( mesh->mMaterialIndex );
+    const unsigned int matIdx(mesh->mMaterialIndex);
 
-    writeFaces( mesh, matIdx );
+    writeFaces(mesh, matIdx);
 
     mModelOutput << "</" << XmlTag::mesh << ">" << std::endl;
 }
 
-void D3MFExporter::writeVertex( const aiVector3D &pos ) {
+void D3MFExporter::writeVertex(const aiVector3D &pos) {
     mModelOutput << "<" << XmlTag::vertex << " x=\"" << pos.x << "\" y=\"" << pos.y << "\" z=\"" << pos.z << "\" />";
     mModelOutput << std::endl;
 }
 
-void D3MFExporter::writeFaces( aiMesh *mesh, unsigned int matIdx ) {
-    if ( nullptr == mesh ) {
+void D3MFExporter::writeFaces(aiMesh *mesh, unsigned int matIdx) {
+    if (nullptr == mesh) {
         return;
     }
 
-    if ( !mesh->HasFaces() ) {
+    if (!mesh->HasFaces()) {
         return;
     }
     mModelOutput << "<" << XmlTag::triangles << ">" << std::endl;
-    for ( unsigned int i = 0; i < mesh->mNumFaces; ++i ) {
-        aiFace &currentFace = mesh->mFaces[ i ];
-        mModelOutput << "<" << XmlTag::triangle << " v1=\"" << currentFace.mIndices[ 0 ] << "\" v2=\""
-                << currentFace.mIndices[ 1 ] << "\" v3=\"" << currentFace.mIndices[ 2 ]
-                << "\" pid=\"1\" p1=\""+to_string(matIdx)+"\" />";
+    for (unsigned int i = 0; i < mesh->mNumFaces; ++i) {
+        aiFace &currentFace = mesh->mFaces[i];
+        mModelOutput << "<" << XmlTag::triangle << " v1=\"" << currentFace.mIndices[0] << "\" v2=\""
+                     << currentFace.mIndices[1] << "\" v3=\"" << currentFace.mIndices[2]
+                     << "\" pid=\"1\" p1=\"" + to_string(matIdx) + "\" />";
         mModelOutput << std::endl;
     }
     mModelOutput << "</" << XmlTag::triangles << ">";
@@ -359,7 +350,7 @@ void D3MFExporter::writeFaces( aiMesh *mesh, unsigned int matIdx ) {
 void D3MFExporter::writeBuild() {
     mModelOutput << "<" << XmlTag::build << ">" << std::endl;
 
-    for ( size_t i = 0; i < mBuildItems.size(); ++i ) {
+    for (size_t i = 0; i < mBuildItems.size(); ++i) {
         mModelOutput << "<" << XmlTag::item << " objectid=\"" << i + 2 << "\"/>";
         mModelOutput << std::endl;
     }
@@ -367,46 +358,45 @@ void D3MFExporter::writeBuild() {
     mModelOutput << std::endl;
 }
 
-void D3MFExporter::exportContentTyp( const std::string &filename ) {
-    if ( nullptr == m_zipArchive ) {
-        throw DeadlyExportError( "3MF-Export: Zip archive not valid, nullptr." );
+void D3MFExporter::exportContentTyp(const std::string &filename) {
+    if (nullptr == m_zipArchive) {
+        throw DeadlyExportError("3MF-Export: Zip archive not valid, nullptr.");
     }
     const std::string entry = filename;
-    zip_entry_open( m_zipArchive, entry.c_str() );
+    zip_entry_open(m_zipArchive, entry.c_str());
 
-    const std::string &exportTxt( mContentOutput.str() );
-    zip_entry_write( m_zipArchive, exportTxt.c_str(), exportTxt.size() );
+    const std::string &exportTxt(mContentOutput.str());
+    zip_entry_write(m_zipArchive, exportTxt.c_str(), exportTxt.size());
 
-    zip_entry_close( m_zipArchive );
+    zip_entry_close(m_zipArchive);
 }
 
-void D3MFExporter::writeModelToArchive( const std::string &folder, const std::string &modelName ) {
-    if ( nullptr == m_zipArchive ) {
-        throw DeadlyExportError( "3MF-Export: Zip archive not valid, nullptr." );
+void D3MFExporter::writeModelToArchive(const std::string &folder, const std::string &modelName) {
+    if (nullptr == m_zipArchive) {
+        throw DeadlyExportError("3MF-Export: Zip archive not valid, nullptr.");
     }
     const std::string entry = folder + "/" + modelName;
-    zip_entry_open( m_zipArchive, entry.c_str() );
+    zip_entry_open(m_zipArchive, entry.c_str());
 
-    const std::string &exportTxt( mModelOutput.str() );
-    zip_entry_write( m_zipArchive, exportTxt.c_str(), exportTxt.size() );
+    const std::string &exportTxt(mModelOutput.str());
+    zip_entry_write(m_zipArchive, exportTxt.c_str(), exportTxt.size());
 
-    zip_entry_close( m_zipArchive );
+    zip_entry_close(m_zipArchive);
 }
 
-void D3MFExporter::writeRelInfoToFile( const std::string &folder, const std::string &relName ) {
-    if ( nullptr == m_zipArchive ) {
-        throw DeadlyExportError( "3MF-Export: Zip archive not valid, nullptr." );
+void D3MFExporter::writeRelInfoToFile(const std::string &folder, const std::string &relName) {
+    if (nullptr == m_zipArchive) {
+        throw DeadlyExportError("3MF-Export: Zip archive not valid, nullptr.");
     }
     const std::string entry = folder + "/" + relName;
-    zip_entry_open( m_zipArchive, entry.c_str() );
+    zip_entry_open(m_zipArchive, entry.c_str());
 
-    const std::string &exportTxt( mRelOutput.str() );
-    zip_entry_write( m_zipArchive, exportTxt.c_str(), exportTxt.size() );
+    const std::string &exportTxt(mRelOutput.str());
+    zip_entry_write(m_zipArchive, exportTxt.c_str(), exportTxt.size());
 
-    zip_entry_close( m_zipArchive );
+    zip_entry_close(m_zipArchive);
 }
 
-
 } // Namespace D3MF
 } // Namespace Assimp
 
diff --git a/code/3MF/D3MFExporter.h b/code/AssetLib/3MF/D3MFExporter.h
similarity index 100%
rename from code/3MF/D3MFExporter.h
rename to code/AssetLib/3MF/D3MFExporter.h
diff --git a/code/3MF/D3MFImporter.cpp b/code/AssetLib/3MF/D3MFImporter.cpp
similarity index 58%
rename from code/3MF/D3MFImporter.cpp
rename to code/AssetLib/3MF/D3MFImporter.cpp
index 2f30c4fc0..9fc9a653d 100644
--- a/code/3MF/D3MFImporter.cpp
+++ b/code/AssetLib/3MF/D3MFImporter.cpp
@@ -44,24 +44,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "D3MFImporter.h"
 
-#include <assimp/scene.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
 #include <assimp/StringComparison.h>
 #include <assimp/StringUtils.h>
 #include <assimp/ZipArchiveIOSystem.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
+#include <cassert>
+#include <map>
+#include <memory>
 #include <string>
 #include <vector>
-#include <map>
-#include <cassert>
-#include <memory>
 
-#include "D3MFOpcPackage.h"
-#include <assimp/irrXMLWrapper.h>
 #include "3MFXmlTags.h"
+#include "D3MFOpcPackage.h"
 #include <assimp/fast_atof.h>
+#include <assimp/irrXMLWrapper.h>
 
 #include <iomanip>
 
@@ -70,90 +70,90 @@ namespace D3MF {
 
 class XmlSerializer {
 public:
-    using MatArray = std::vector<aiMaterial*>;
+    using MatArray = std::vector<aiMaterial *>;
     using MatId2MatArray = std::map<unsigned int, std::vector<unsigned int>>;
 
-    XmlSerializer(XmlReader* xmlReader)
-    : mMeshes()
-    , mMatArray()
-    , mActiveMatGroup( 99999999 )
-    , mMatId2MatArray()
-    , xmlReader(xmlReader){
-		// empty
+    XmlSerializer(XmlReader *xmlReader) :
+            mMeshes(),
+            mMatArray(),
+            mActiveMatGroup(99999999),
+            mMatId2MatArray(),
+            xmlReader(xmlReader) {
+        // empty
     }
 
     ~XmlSerializer() {
         // empty
     }
 
-    void ImportXml(aiScene* scene) {
-        if ( nullptr == scene ) {
+    void ImportXml(aiScene *scene) {
+        if (nullptr == scene) {
             return;
         }
 
         scene->mRootNode = new aiNode();
-        std::vector<aiNode*> children;
+        std::vector<aiNode *> children;
 
         std::string nodeName;
-        while(ReadToEndElement(D3MF::XmlTag::model)) {
+        while (ReadToEndElement(D3MF::XmlTag::model)) {
             nodeName = xmlReader->getNodeName();
-            if( nodeName == D3MF::XmlTag::object) {
+            if (nodeName == D3MF::XmlTag::object) {
                 children.push_back(ReadObject(scene));
-            } else if( nodeName == D3MF::XmlTag::build) {
-                // 
-            } else if ( nodeName == D3MF::XmlTag::basematerials ) {
+            } else if (nodeName == D3MF::XmlTag::build) {
+                //
+            } else if (nodeName == D3MF::XmlTag::basematerials) {
                 ReadBaseMaterials();
-            } else if ( nodeName == D3MF::XmlTag::meta ) {
+            } else if (nodeName == D3MF::XmlTag::meta) {
                 ReadMetadata();
             }
         }
 
-        if ( scene->mRootNode->mName.length == 0 ) {
-            scene->mRootNode->mName.Set( "3MF" );
+        if (scene->mRootNode->mName.length == 0) {
+            scene->mRootNode->mName.Set("3MF");
         }
 
         // import the metadata
-        if ( !mMetaData.empty() ) {
-            const size_t numMeta( mMetaData.size() );
-            scene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>( numMeta ) );
-            for ( size_t i = 0; i < numMeta; ++i ) {
-                aiString val( mMetaData[ i ].value );
-                scene->mMetaData->Set(static_cast<unsigned int>( i ), mMetaData[ i ].name, val );
+        if (!mMetaData.empty()) {
+            const size_t numMeta(mMetaData.size());
+            scene->mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(numMeta));
+            for (size_t i = 0; i < numMeta; ++i) {
+                aiString val(mMetaData[i].value);
+                scene->mMetaData->Set(static_cast<unsigned int>(i), mMetaData[i].name, val);
             }
         }
 
         // import the meshes
-        scene->mNumMeshes = static_cast<unsigned int>( mMeshes.size());
-        scene->mMeshes = new aiMesh*[scene->mNumMeshes]();
-        std::copy( mMeshes.begin(), mMeshes.end(), scene->mMeshes);
+        scene->mNumMeshes = static_cast<unsigned int>(mMeshes.size());
+        scene->mMeshes = new aiMesh *[scene->mNumMeshes]();
+        std::copy(mMeshes.begin(), mMeshes.end(), scene->mMeshes);
 
         // import the materials
-        scene->mNumMaterials = static_cast<unsigned int>( mMatArray.size() );
-        if ( 0 != scene->mNumMaterials ) {
-            scene->mMaterials = new aiMaterial*[ scene->mNumMaterials ];
-            std::copy( mMatArray.begin(), mMatArray.end(), scene->mMaterials );
+        scene->mNumMaterials = static_cast<unsigned int>(mMatArray.size());
+        if (0 != scene->mNumMaterials) {
+            scene->mMaterials = new aiMaterial *[scene->mNumMaterials];
+            std::copy(mMatArray.begin(), mMatArray.end(), scene->mMaterials);
         }
 
         // create the scenegraph
         scene->mRootNode->mNumChildren = static_cast<unsigned int>(children.size());
-        scene->mRootNode->mChildren = new aiNode*[scene->mRootNode->mNumChildren]();
+        scene->mRootNode->mChildren = new aiNode *[scene->mRootNode->mNumChildren]();
         std::copy(children.begin(), children.end(), scene->mRootNode->mChildren);
     }
 
 private:
-    aiNode* ReadObject(aiScene* scene) {
+    aiNode *ReadObject(aiScene *scene) {
         std::unique_ptr<aiNode> node(new aiNode());
 
         std::vector<unsigned long> meshIds;
 
-        const char *attrib( nullptr );
+        const char *attrib(nullptr);
         std::string name, type;
-        attrib = xmlReader->getAttributeValue( D3MF::XmlTag::id.c_str() );
-        if ( nullptr != attrib ) {
+        attrib = xmlReader->getAttributeValue(D3MF::XmlTag::id.c_str());
+        if (nullptr != attrib) {
             name = attrib;
         }
-        attrib = xmlReader->getAttributeValue( D3MF::XmlTag::type.c_str() );
-        if ( nullptr != attrib ) {
+        attrib = xmlReader->getAttributeValue(D3MF::XmlTag::type.c_str());
+        if (nullptr != attrib) {
             type = attrib;
         }
 
@@ -162,8 +162,8 @@ private:
 
         size_t meshIdx = mMeshes.size();
 
-        while(ReadToEndElement(D3MF::XmlTag::object)) {
-            if(xmlReader->getNodeName() == D3MF::XmlTag::mesh) {
+        while (ReadToEndElement(D3MF::XmlTag::object)) {
+            if (xmlReader->getNodeName() == D3MF::XmlTag::mesh) {
                 auto mesh = ReadMesh();
 
                 mesh->mName.Set(name);
@@ -183,11 +183,11 @@ private:
     }
 
     aiMesh *ReadMesh() {
-        aiMesh* mesh = new aiMesh();
-        while(ReadToEndElement(D3MF::XmlTag::mesh)) {
-            if(xmlReader->getNodeName() == D3MF::XmlTag::vertices) {
+        aiMesh *mesh = new aiMesh();
+        while (ReadToEndElement(D3MF::XmlTag::mesh)) {
+            if (xmlReader->getNodeName() == D3MF::XmlTag::vertices) {
                 ImportVertices(mesh);
-            } else if(xmlReader->getNodeName() == D3MF::XmlTag::triangles) {
+            } else if (xmlReader->getNodeName() == D3MF::XmlTag::triangles) {
                 ImportTriangles(mesh);
             }
         }
@@ -196,24 +196,24 @@ private:
     }
 
     void ReadMetadata() {
-        const std::string name = xmlReader->getAttributeValue( D3MF::XmlTag::meta_name.c_str() );
+        const std::string name = xmlReader->getAttributeValue(D3MF::XmlTag::meta_name.c_str());
         xmlReader->read();
         const std::string value = xmlReader->getNodeData();
 
-        if ( name.empty() ) {
+        if (name.empty()) {
             return;
         }
 
         MetaEntry entry;
         entry.name = name;
         entry.value = value;
-        mMetaData.push_back( entry );
+        mMetaData.push_back(entry);
     }
 
-    void ImportVertices(aiMesh* mesh) {
+    void ImportVertices(aiMesh *mesh) {
         std::vector<aiVector3D> vertices;
-        while(ReadToEndElement(D3MF::XmlTag::vertices)) {
-            if(xmlReader->getNodeName() == D3MF::XmlTag::vertex) {
+        while (ReadToEndElement(D3MF::XmlTag::vertices)) {
+            if (xmlReader->getNodeName() == D3MF::XmlTag::vertex) {
                 vertices.push_back(ReadVertex());
             }
         }
@@ -233,20 +233,20 @@ private:
         return vertex;
     }
 
-    void ImportTriangles(aiMesh* mesh) {
-         std::vector<aiFace> faces;
+    void ImportTriangles(aiMesh *mesh) {
+        std::vector<aiFace> faces;
 
-         while(ReadToEndElement(D3MF::XmlTag::triangles)) {
-             const std::string nodeName( xmlReader->getNodeName() );
-             if(xmlReader->getNodeName() == D3MF::XmlTag::triangle) {
-                 faces.push_back(ReadTriangle());
-                 const char *pidToken( xmlReader->getAttributeValue( D3MF::XmlTag::p1.c_str() ) );
-                 if ( nullptr != pidToken ) {
-                     int matIdx( std::atoi( pidToken ) );
-                     mesh->mMaterialIndex = matIdx;
-                 }
-             }
-         }
+        while (ReadToEndElement(D3MF::XmlTag::triangles)) {
+            const std::string nodeName(xmlReader->getNodeName());
+            if (xmlReader->getNodeName() == D3MF::XmlTag::triangle) {
+                faces.push_back(ReadTriangle());
+                const char *pidToken(xmlReader->getAttributeValue(D3MF::XmlTag::p1.c_str()));
+                if (nullptr != pidToken) {
+                    int matIdx(std::atoi(pidToken));
+                    mesh->mMaterialIndex = matIdx;
+                }
+            }
+        }
 
         mesh->mNumFaces = static_cast<unsigned int>(faces.size());
         mesh->mFaces = new aiFace[mesh->mNumFaces];
@@ -269,117 +269,115 @@ private:
 
     void ReadBaseMaterials() {
         std::vector<unsigned int> MatIdArray;
-        const char *baseMaterialId( xmlReader->getAttributeValue( D3MF::XmlTag::basematerials_id.c_str() ) );
-        if ( nullptr != baseMaterialId ) {
-            unsigned int id = std::atoi( baseMaterialId );
-            const size_t newMatIdx( mMatArray.size() );
-            if ( id != mActiveMatGroup ) {
+        const char *baseMaterialId(xmlReader->getAttributeValue(D3MF::XmlTag::basematerials_id.c_str()));
+        if (nullptr != baseMaterialId) {
+            unsigned int id = std::atoi(baseMaterialId);
+            const size_t newMatIdx(mMatArray.size());
+            if (id != mActiveMatGroup) {
                 mActiveMatGroup = id;
-                MatId2MatArray::const_iterator it( mMatId2MatArray.find( id ) );
-                if ( mMatId2MatArray.end() == it ) {
+                MatId2MatArray::const_iterator it(mMatId2MatArray.find(id));
+                if (mMatId2MatArray.end() == it) {
                     MatIdArray.clear();
-                    mMatId2MatArray[ id ] = MatIdArray;
+                    mMatId2MatArray[id] = MatIdArray;
                 } else {
                     MatIdArray = it->second;
                 }
             }
-            MatIdArray.push_back( static_cast<unsigned int>( newMatIdx ) );
-            mMatId2MatArray[ mActiveMatGroup ] = MatIdArray;
+            MatIdArray.push_back(static_cast<unsigned int>(newMatIdx));
+            mMatId2MatArray[mActiveMatGroup] = MatIdArray;
         }
 
-        while ( ReadToEndElement( D3MF::XmlTag::basematerials ) ) {
-            mMatArray.push_back( readMaterialDef() );
+        while (ReadToEndElement(D3MF::XmlTag::basematerials)) {
+            mMatArray.push_back(readMaterialDef());
         }
     }
 
-    bool parseColor( const char *color, aiColor4D &diffuse ) {
-        if ( nullptr == color ) {
+    bool parseColor(const char *color, aiColor4D &diffuse) {
+        if (nullptr == color) {
             return false;
         }
 
         //format of the color string: #RRGGBBAA or #RRGGBB (3MF Core chapter 5.1.1)
-        const size_t len( strlen( color ) );
-        if ( 9 != len && 7 != len) {
+        const size_t len(strlen(color));
+        if (9 != len && 7 != len) {
             return false;
         }
 
-        const char *buf( color );
-        if ( '#' != *buf ) {
+        const char *buf(color);
+        if ('#' != *buf) {
             return false;
         }
         ++buf;
-        char comp[ 3 ] = { 0,0,'\0' };
+        char comp[3] = { 0, 0, '\0' };
 
-        comp[ 0 ] = *buf;
+        comp[0] = *buf;
         ++buf;
-        comp[ 1 ] = *buf;
+        comp[1] = *buf;
         ++buf;
-        diffuse.r = static_cast<ai_real>( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
+        diffuse.r = static_cast<ai_real>(strtol(comp, NULL, 16)) / ai_real(255.0);
 
+        comp[0] = *buf;
+        ++buf;
+        comp[1] = *buf;
+        ++buf;
+        diffuse.g = static_cast<ai_real>(strtol(comp, NULL, 16)) / ai_real(255.0);
 
-        comp[ 0 ] = *buf;
+        comp[0] = *buf;
         ++buf;
-        comp[ 1 ] = *buf;
+        comp[1] = *buf;
         ++buf;
-        diffuse.g = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
+        diffuse.b = static_cast<ai_real>(strtol(comp, NULL, 16)) / ai_real(255.0);
 
-        comp[ 0 ] = *buf;
-        ++buf;
-        comp[ 1 ] = *buf;
-        ++buf;
-        diffuse.b = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
-
-        if(7 == len)
+        if (7 == len)
             return true;
-        comp[ 0 ] = *buf;
+        comp[0] = *buf;
         ++buf;
-        comp[ 1 ] = *buf;
+        comp[1] = *buf;
         ++buf;
-        diffuse.a = static_cast< ai_real >( strtol( comp, NULL, 16 ) ) / ai_real(255.0);
+        diffuse.a = static_cast<ai_real>(strtol(comp, NULL, 16)) / ai_real(255.0);
 
         return true;
     }
 
-    void assignDiffuseColor( aiMaterial *mat ) {
-        const char *color = xmlReader->getAttributeValue( D3MF::XmlTag::basematerials_displaycolor.c_str() );
+    void assignDiffuseColor(aiMaterial *mat) {
+        const char *color = xmlReader->getAttributeValue(D3MF::XmlTag::basematerials_displaycolor.c_str());
         aiColor4D diffuse;
-        if ( parseColor( color, diffuse ) ) {
-            mat->AddProperty<aiColor4D>( &diffuse, 1, AI_MATKEY_COLOR_DIFFUSE );
+        if (parseColor(color, diffuse)) {
+            mat->AddProperty<aiColor4D>(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
         }
-
     }
     aiMaterial *readMaterialDef() {
-        aiMaterial *mat( nullptr );
-        const char *name( nullptr );
-        const std::string nodeName( xmlReader->getNodeName() );
-        if ( nodeName == D3MF::XmlTag::basematerials_base ) {
-            name = xmlReader->getAttributeValue( D3MF::XmlTag::basematerials_name.c_str() );
+        aiMaterial *mat(nullptr);
+        const char *name(nullptr);
+        const std::string nodeName(xmlReader->getNodeName());
+        if (nodeName == D3MF::XmlTag::basematerials_base) {
+            name = xmlReader->getAttributeValue(D3MF::XmlTag::basematerials_name.c_str());
             std::string stdMatName;
             aiString matName;
-            std::string strId( to_string( mActiveMatGroup ) );
+            std::string strId(to_string(mActiveMatGroup));
             stdMatName += "id";
             stdMatName += strId;
             stdMatName += "_";
-            if ( nullptr != name ) {
-                stdMatName += std::string( name );
+            if (nullptr != name) {
+                stdMatName += std::string(name);
             } else {
                 stdMatName += "basemat";
             }
-            matName.Set( stdMatName );
+            matName.Set(stdMatName);
 
             mat = new aiMaterial;
-            mat->AddProperty( &matName, AI_MATKEY_NAME );
+            mat->AddProperty(&matName, AI_MATKEY_NAME);
 
-            assignDiffuseColor( mat );
+            assignDiffuseColor(mat);
         }
 
         return mat;
     }
 
 private:
-    bool ReadToStartElement(const std::string& startTag) {
-        while(xmlReader->read()) {
-            const std::string &nodeName( xmlReader->getNodeName() );
+    bool ReadToStartElement(const std::string &startTag) {
+        while (xmlReader->read()) {
+            const std::string &nodeName(xmlReader->getNodeName());
             if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT && nodeName == startTag) {
                 return true;
             } else if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT_END && nodeName == startTag) {
@@ -390,9 +388,9 @@ private:
         return false;
     }
 
-    bool ReadToEndElement(const std::string& closeTag) {
-        while(xmlReader->read()) {
-            const std::string &nodeName( xmlReader->getNodeName() );
+    bool ReadToEndElement(const std::string &closeTag) {
+        while (xmlReader->read()) {
+            const std::string &nodeName(xmlReader->getNodeName());
             if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT) {
                 return true;
             } else if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT_END && nodeName == closeTag) {
@@ -410,11 +408,11 @@ private:
         std::string value;
     };
     std::vector<MetaEntry> mMetaData;
-    std::vector<aiMesh*> mMeshes;
+    std::vector<aiMesh *> mMeshes;
     MatArray mMatArray;
     unsigned int mActiveMatGroup;
     MatId2MatArray mMatId2MatArray;
-    XmlReader* xmlReader;
+    XmlReader *xmlReader;
 };
 
 } //namespace D3MF
@@ -432,8 +430,8 @@ static const aiImporterDesc desc = {
     "3mf"
 };
 
-D3MFImporter::D3MFImporter()
-: BaseImporter() {
+D3MFImporter::D3MFImporter() :
+        BaseImporter() {
     // empty
 }
 
@@ -442,17 +440,17 @@ D3MFImporter::~D3MFImporter() {
 }
 
 bool D3MFImporter::CanRead(const std::string &filename, IOSystem *pIOHandler, bool checkSig) const {
-    const std::string extension( GetExtension( filename ) );
-    if(extension == desc.mFileExtensions ) {
+    const std::string extension(GetExtension(filename));
+    if (extension == desc.mFileExtensions) {
         return true;
-    } else if ( !extension.length() || checkSig ) {
-        if ( nullptr == pIOHandler ) {
+    } else if (!extension.length() || checkSig) {
+        if (nullptr == pIOHandler) {
             return false;
         }
-        if ( !ZipArchiveIOSystem::isZipArchive( pIOHandler, filename ) ) {
+        if (!ZipArchiveIOSystem::isZipArchive(pIOHandler, filename)) {
             return false;
         }
-        D3MF::D3MFOpcPackage opcPackage( pIOHandler, filename );
+        D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
         return opcPackage.validate();
     }
 
@@ -467,7 +465,7 @@ const aiImporterDesc *D3MFImporter::GetInfo() const {
     return &desc;
 }
 
-void D3MFImporter::InternReadFile( const std::string &filename, aiScene *pScene, IOSystem *pIOHandler ) {
+void D3MFImporter::InternReadFile(const std::string &filename, aiScene *pScene, IOSystem *pIOHandler) {
     D3MF::D3MFOpcPackage opcPackage(pIOHandler, filename);
 
     std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream()));
diff --git a/code/3MF/D3MFImporter.h b/code/AssetLib/3MF/D3MFImporter.h
similarity index 100%
rename from code/3MF/D3MFImporter.h
rename to code/AssetLib/3MF/D3MFImporter.h
diff --git a/code/3MF/D3MFOpcPackage.cpp b/code/AssetLib/3MF/D3MFOpcPackage.cpp
similarity index 100%
rename from code/3MF/D3MFOpcPackage.cpp
rename to code/AssetLib/3MF/D3MFOpcPackage.cpp
diff --git a/code/3MF/D3MFOpcPackage.h b/code/AssetLib/3MF/D3MFOpcPackage.h
similarity index 100%
rename from code/3MF/D3MFOpcPackage.h
rename to code/AssetLib/3MF/D3MFOpcPackage.h
diff --git a/code/AC/ACLoader.cpp b/code/AssetLib/AC/ACLoader.cpp
similarity index 94%
rename from code/AC/ACLoader.cpp
rename to code/AssetLib/AC/ACLoader.cpp
index 85aee7e3a..40ff8dc86 100644
--- a/code/AC/ACLoader.cpp
+++ b/code/AssetLib/AC/ACLoader.cpp
@@ -192,7 +192,7 @@ void AC3DImporter::LoadObjectSection(std::vector<Object> &objects) {
     objects.push_back(Object());
     Object &obj = objects.back();
 
-    aiLight *light = NULL;
+    aiLight *light = nullptr;
     if (!ASSIMP_strincmp(buffer, "light", 5)) {
         // This is a light source. Add it to the list
         mLights->push_back(light = new aiLight());
@@ -472,29 +472,29 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
                 }
 
                 switch ((*it).flags & 0xf) {
-                        // closed line
-                    case 0x1:
-                        needMat[idx].first += (unsigned int)(*it).entries.size();
-                        needMat[idx].second += (unsigned int)(*it).entries.size() << 1u;
-                        break;
+                    // closed line
+                case 0x1:
+                    needMat[idx].first += (unsigned int)(*it).entries.size();
+                    needMat[idx].second += (unsigned int)(*it).entries.size() << 1u;
+                    break;
 
-                        // unclosed line
-                    case 0x2:
-                        needMat[idx].first += (unsigned int)(*it).entries.size() - 1;
-                        needMat[idx].second += ((unsigned int)(*it).entries.size() - 1) << 1u;
-                        break;
+                    // unclosed line
+                case 0x2:
+                    needMat[idx].first += (unsigned int)(*it).entries.size() - 1;
+                    needMat[idx].second += ((unsigned int)(*it).entries.size() - 1) << 1u;
+                    break;
 
-                        // 0 == polygon, else unknown
-                    default:
-                        if ((*it).flags & 0xf) {
-                            ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown");
-                            (*it).flags &= ~(0xf);
-                        }
+                    // 0 == polygon, else unknown
+                default:
+                    if ((*it).flags & 0xf) {
+                        ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown");
+                        (*it).flags &= ~(0xf);
+                    }
 
-                        // the number of faces increments by one, the number
-                        // of vertices by surface.numref.
-                        needMat[idx].first++;
-                        needMat[idx].second += (unsigned int)(*it).entries.size();
+                    // the number of faces increments by one, the number
+                    // of vertices by surface.numref.
+                    needMat[idx].first++;
+                    needMat[idx].second += (unsigned int)(*it).entries.size();
                 };
             }
             unsigned int *pip = node->mMeshes = new unsigned int[node->mNumMeshes];
@@ -535,7 +535,7 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
 
                 // allocate UV coordinates, but only if the texture name for the
                 // surface is not empty
-                aiVector3D *uv = NULL;
+                aiVector3D *uv = nullptr;
                 if (object.texture.length()) {
                     uv = mesh->mTextureCoords[0] = new aiVector3D[mesh->mNumVertices];
                     mesh->mNumUVComponents[0] = 2;
@@ -644,20 +644,20 @@ aiNode *AC3DImporter::ConvertObjectSection(Object &object,
     else {
         // generate a name depending on the type of the node
         switch (object.type) {
-            case Object::Group:
-                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i", mGroupsCounter++);
-                break;
-            case Object::Poly:
-                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i", mPolysCounter++);
-                break;
-            case Object::Light:
-                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i", mLightsCounter++);
-                break;
+        case Object::Group:
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACGroup_%i", mGroupsCounter++);
+            break;
+        case Object::Poly:
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACPoly_%i", mPolysCounter++);
+            break;
+        case Object::Light:
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACLight_%i", mLightsCounter++);
+            break;
 
-                // there shouldn't be more than one world, but we don't care
-            case Object::World:
-                node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i", mWorldsCounter++);
-                break;
+            // there shouldn't be more than one world, but we don't care
+        case Object::World:
+            node->mName.length = ::ai_snprintf(node->mName.data, MAXLEN, "ACWorld_%i", mWorldsCounter++);
+            break;
         }
     }
 
@@ -696,7 +696,7 @@ void AC3DImporter::InternReadFile(const std::string &pFile,
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if ( file.get() == nullptr ) {
+    if (file.get() == nullptr) {
         throw DeadlyImportError("Failed to open AC3D file " + pFile + ".");
     }
 
diff --git a/code/AC/ACLoader.h b/code/AssetLib/AC/ACLoader.h
similarity index 78%
rename from code/AC/ACLoader.h
rename to code/AssetLib/AC/ACLoader.h
index b32cc7ee3..e330ddf1b 100644
--- a/code/AC/ACLoader.h
+++ b/code/AssetLib/AC/ACLoader.h
@@ -56,27 +56,20 @@ struct aiMesh;
 struct aiMaterial;
 struct aiLight;
 
-
-namespace Assimp    {
+namespace Assimp {
 
 // ---------------------------------------------------------------------------
 /** AC3D (*.ac) importer class
 */
-class AC3DImporter : public BaseImporter
-{
+class AC3DImporter : public BaseImporter {
 public:
     AC3DImporter();
     ~AC3DImporter();
 
     // Represents an AC3D material
-    struct Material
-    {
-        Material()
-            :   rgb     (0.6f,0.6f,0.6f)
-            ,   spec    (1.f,1.f,1.f)
-            ,   shin    (0.f)
-            ,   trans   (0.f)
-        {}
+    struct Material {
+        Material() :
+                rgb(0.6f, 0.6f, 0.6f), spec(1.f, 1.f, 1.f), shin(0.f), trans(0.f) {}
 
         // base color of the material
         aiColor3D rgb;
@@ -101,43 +94,25 @@ public:
     };
 
     // Represents an AC3D surface
-    struct Surface
-    {
-        Surface()
-            :   mat     (0)
-            ,   flags   (0)
-        {}
+    struct Surface {
+        Surface() :
+                mat(0), flags(0) {}
 
-        unsigned int mat,flags;
+        unsigned int mat, flags;
 
-        typedef std::pair<unsigned int, aiVector2D > SurfaceEntry;
-        std::vector< SurfaceEntry > entries;
+        typedef std::pair<unsigned int, aiVector2D> SurfaceEntry;
+        std::vector<SurfaceEntry> entries;
     };
 
     // Represents an AC3D object
-    struct Object
-    {
-        Object()
-            :   type    (World)
-            ,   name( "" )
-            ,   children()
-            ,   texture( "" )
-            ,   texRepeat( 1.f, 1.f )
-            ,   texOffset( 0.0f, 0.0f )
-            ,   rotation()
-            ,   translation()
-            ,   vertices()
-            ,   surfaces()
-            ,   numRefs (0)
-            ,   subDiv  (0)
-            ,   crease()
-        {}
+    struct Object {
+        Object() :
+                type(World), name(""), children(), texture(""), texRepeat(1.f, 1.f), texOffset(0.0f, 0.0f), rotation(), translation(), vertices(), surfaces(), numRefs(0), subDiv(0), crease() {}
 
         // Type description
-        enum Type
-        {
+        enum Type {
             World = 0x0,
-            Poly  = 0x1,
+            Poly = 0x1,
             Group = 0x2,
             Light = 0x4
         } type;
@@ -177,37 +152,33 @@ public:
         float crease;
     };
 
-
 public:
-
     // -------------------------------------------------------------------
     /** 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;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const;
 
 protected:
-
     // -------------------------------------------------------------------
     /** Return importer meta information.
      * See #BaseImporter::GetInfo for the details */
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const;
 
     // -------------------------------------------------------------------
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details*/
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler);
 
     // -------------------------------------------------------------------
     /** Called prior to ReadFile().
     * The function is a request to the importer to update its configuration
     * basing on the Importer's configuration property list.*/
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp);
 
 private:
-
     // -------------------------------------------------------------------
     /** Get the next line from the file.
      *  @return false if the end of the file was reached*/
@@ -218,7 +189,7 @@ private:
      *  load subobjects, the method returns after a 'kids 0' was
      *  encountered.
      *  @objects List of output objects*/
-    void LoadObjectSection(std::vector<Object>& objects);
+    void LoadObjectSection(std::vector<Object> &objects);
 
     // -------------------------------------------------------------------
     /** Convert all objects into meshes and nodes.
@@ -227,24 +198,24 @@ private:
      *  @param outMaterials List of output materials
      *  @param materials Material list
      *  @param Scenegraph node for the object */
-    aiNode* ConvertObjectSection(Object& object,
-        std::vector<aiMesh*>& meshes,
-        std::vector<aiMaterial*>& outMaterials,
-        const std::vector<Material>& materials,
-        aiNode* parent = NULL);
+    aiNode *ConvertObjectSection(Object &object,
+            std::vector<aiMesh *> &meshes,
+            std::vector<aiMaterial *> &outMaterials,
+            const std::vector<Material> &materials,
+            aiNode *parent = nullptr);
 
     // -------------------------------------------------------------------
     /** Convert a material
      *  @param object Current object
      *  @param matSrc Source material description
      *  @param matDest Destination material to be filled */
-    void ConvertMaterial(const Object& object,
-        const Material& matSrc,
-        aiMaterial& matDest);
+    void ConvertMaterial(const Object &object,
+            const Material &matSrc,
+            aiMaterial &matDest);
 
 private:
     // points to the next data line
-    const char* buffer;
+    const char *buffer;
 
     // Configuration option: if enabled, up to two meshes
     // are generated per material: those faces who have
@@ -261,7 +232,7 @@ private:
     unsigned int mNumMeshes;
 
     // current list of light sources
-    std::vector<aiLight*>* mLights;
+    std::vector<aiLight *> *mLights;
 
     // name counters
     unsigned int mLightsCounter, mGroupsCounter, mPolysCounter, mWorldsCounter;
diff --git a/code/AssetLib/AMF/AMFImporter.cpp b/code/AssetLib/AMF/AMFImporter.cpp
new file mode 100644
index 000000000..3bb18b0ab
--- /dev/null
+++ b/code/AssetLib/AMF/AMFImporter.cpp
@@ -0,0 +1,672 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 AMFImporter.cpp
+/// \brief AMF-format files importer for Assimp: main algorithm implementation.
+/// \date 2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
+
+// Header files, Assimp.
+#include "AMFImporter.hpp"
+#include "AMFImporter_Macro.hpp"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/fast_atof.h>
+
+// Header files, stdlib.
+#include <memory>
+
+namespace Assimp {
+
+/// \var aiImporterDesc AMFImporter::Description
+/// Conastant which hold importer description
+const aiImporterDesc AMFImporter::Description = {
+    "Additive manufacturing file format(AMF) Importer",
+    "smalcom",
+    "",
+    "See documentation in source code. Chapter: Limitations.",
+    aiImporterFlags_SupportTextFlavour | aiImporterFlags_LimitedSupport | aiImporterFlags_Experimental,
+    0,
+    0,
+    0,
+    0,
+    "amf"
+};
+
+void AMFImporter::Clear() {
+    mNodeElement_Cur = nullptr;
+    mUnit.clear();
+    mMaterial_Converted.clear();
+    mTexture_Converted.clear();
+    // Delete all elements
+    if (!mNodeElement_List.empty()) {
+        for (CAMFImporter_NodeElement *ne : mNodeElement_List) {
+            delete ne;
+        }
+
+        mNodeElement_List.clear();
+    }
+}
+
+AMFImporter::~AMFImporter() {
+    if (mReader != nullptr) delete mReader;
+    // Clear() is accounting if data already is deleted. So, just check again if all data is deleted.
+    Clear();
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: find set ************************************************************/
+/*********************************************************************************************************************************************/
+
+bool AMFImporter::Find_NodeElement(const std::string &pID, const CAMFImporter_NodeElement::EType pType, CAMFImporter_NodeElement **pNodeElement) const {
+    for (CAMFImporter_NodeElement *ne : mNodeElement_List) {
+        if ((ne->ID == pID) && (ne->Type == pType)) {
+            if (pNodeElement != nullptr) *pNodeElement = ne;
+
+            return true;
+        }
+    } // for(CAMFImporter_NodeElement* ne: mNodeElement_List)
+
+    return false;
+}
+
+bool AMFImporter::Find_ConvertedNode(const std::string &pID, std::list<aiNode *> &pNodeList, aiNode **pNode) const {
+    aiString node_name(pID.c_str());
+
+    for (aiNode *node : pNodeList) {
+        if (node->mName == node_name) {
+            if (pNode != nullptr) *pNode = node;
+
+            return true;
+        }
+    } // for(aiNode* node: pNodeList)
+
+    return false;
+}
+
+bool AMFImporter::Find_ConvertedMaterial(const std::string &pID, const SPP_Material **pConvertedMaterial) const {
+    for (const SPP_Material &mat : mMaterial_Converted) {
+        if (mat.ID == pID) {
+            if (pConvertedMaterial != nullptr) *pConvertedMaterial = &mat;
+
+            return true;
+        }
+    } // for(const SPP_Material& mat: mMaterial_Converted)
+
+    return false;
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: throw set ***********************************************************/
+/*********************************************************************************************************************************************/
+
+void AMFImporter::Throw_CloseNotFound(const std::string &pNode) {
+    throw DeadlyImportError("Close tag for node <" + pNode + "> not found. Seems file is corrupt.");
+}
+
+void AMFImporter::Throw_IncorrectAttr(const std::string &pAttrName) {
+    throw DeadlyImportError("Node <" + std::string(mReader->getNodeName()) + "> has incorrect attribute \"" + pAttrName + "\".");
+}
+
+void AMFImporter::Throw_IncorrectAttrValue(const std::string &pAttrName) {
+    throw DeadlyImportError("Attribute \"" + pAttrName + "\" in node <" + std::string(mReader->getNodeName()) + "> has incorrect value.");
+}
+
+void AMFImporter::Throw_MoreThanOnceDefined(const std::string &pNodeType, const std::string &pDescription) {
+    throw DeadlyImportError("\"" + pNodeType + "\" node can be used only once in " + mReader->getNodeName() + ". Description: " + pDescription);
+}
+
+void AMFImporter::Throw_ID_NotFound(const std::string &pID) const {
+    throw DeadlyImportError("Not found node with name \"" + pID + "\".");
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************* Functions: XML set ************************************************************/
+/*********************************************************************************************************************************************/
+
+void AMFImporter::XML_CheckNode_MustHaveChildren() {
+    if (mReader->isEmptyElement()) throw DeadlyImportError(std::string("Node <") + mReader->getNodeName() + "> must have children.");
+}
+
+void AMFImporter::XML_CheckNode_SkipUnsupported(const std::string &pParentNodeName) {
+    static const size_t Uns_Skip_Len = 3;
+    const char *Uns_Skip[Uns_Skip_Len] = { "composite", "edge", "normal" };
+
+    static bool skipped_before[Uns_Skip_Len] = { false, false, false };
+
+    std::string nn(mReader->getNodeName());
+    bool found = false;
+    bool close_found = false;
+    size_t sk_idx;
+
+    for (sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++) {
+        if (nn != Uns_Skip[sk_idx]) continue;
+
+        found = true;
+        if (mReader->isEmptyElement()) {
+            close_found = true;
+
+            goto casu_cres;
+        }
+
+        while (mReader->read()) {
+            if ((mReader->getNodeType() == irr::io::EXN_ELEMENT_END) && (nn == mReader->getNodeName())) {
+                close_found = true;
+
+                goto casu_cres;
+            }
+        }
+    } // for(sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++)
+
+casu_cres:
+
+    if (!found) throw DeadlyImportError("Unknown node \"" + nn + "\" in " + pParentNodeName + ".");
+    if (!close_found) Throw_CloseNotFound(nn);
+
+    if (!skipped_before[sk_idx]) {
+        skipped_before[sk_idx] = true;
+        ASSIMP_LOG_WARN_F("Skipping node \"", nn, "\" in ", pParentNodeName, ".");
+    }
+}
+
+bool AMFImporter::XML_SearchNode(const std::string &pNodeName) {
+    while (mReader->read()) {
+        if ((mReader->getNodeType() == irr::io::EXN_ELEMENT) && XML_CheckNode_NameEqual(pNodeName)) return true;
+    }
+
+    return false;
+}
+
+bool AMFImporter::XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx) {
+    std::string val(mReader->getAttributeValue(pAttrIdx));
+
+    if ((val == "false") || (val == "0"))
+        return false;
+    else if ((val == "true") || (val == "1"))
+        return true;
+    else
+        throw DeadlyImportError("Bool attribute value can contain \"false\"/\"0\" or \"true\"/\"1\" not the \"" + val + "\"");
+}
+
+float AMFImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx) {
+    std::string val;
+    float tvalf;
+
+    ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val);
+    fast_atoreal_move(val.c_str(), tvalf, false);
+
+    return tvalf;
+}
+
+uint32_t AMFImporter::XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx) {
+    return strtoul10(mReader->getAttributeValue(pAttrIdx));
+}
+
+float AMFImporter::XML_ReadNode_GetVal_AsFloat() {
+    std::string val;
+    float tvalf;
+
+    if (!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. No data, seems file is corrupt.");
+    if (mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. Invalid type of XML element, seems file is corrupt.");
+
+    ParseHelper_FixTruncatedFloatString(mReader->getNodeData(), val);
+    fast_atoreal_move(val.c_str(), tvalf, false);
+
+    return tvalf;
+}
+
+uint32_t AMFImporter::XML_ReadNode_GetVal_AsU32() {
+    if (!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. No data, seems file is corrupt.");
+    if (mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsU32. Invalid type of XML element, seems file is corrupt.");
+
+    return strtoul10(mReader->getNodeData());
+}
+
+void AMFImporter::XML_ReadNode_GetVal_AsString(std::string &pValue) {
+    if (!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsString. No data, seems file is corrupt.");
+    if (mReader->getNodeType() != irr::io::EXN_TEXT)
+        throw DeadlyImportError("XML_ReadNode_GetVal_AsString. Invalid type of XML element, seems file is corrupt.");
+
+    pValue = mReader->getNodeData();
+}
+
+/*********************************************************************************************************************************************/
+/************************************************************ Functions: parse set ***********************************************************/
+/*********************************************************************************************************************************************/
+
+void AMFImporter::ParseHelper_Node_Enter(CAMFImporter_NodeElement *pNode) {
+    mNodeElement_Cur->Child.push_back(pNode); // add new element to current element child list.
+    mNodeElement_Cur = pNode; // switch current element to new one.
+}
+
+void AMFImporter::ParseHelper_Node_Exit() {
+    // check if we can walk up.
+    if (mNodeElement_Cur != nullptr) mNodeElement_Cur = mNodeElement_Cur->Parent;
+}
+
+void AMFImporter::ParseHelper_FixTruncatedFloatString(const char *pInStr, std::string &pOutString) {
+    size_t instr_len;
+
+    pOutString.clear();
+    instr_len = strlen(pInStr);
+    if (!instr_len) return;
+
+    pOutString.reserve(instr_len * 3 / 2);
+    // check and correct floats in format ".x". Must be "x.y".
+    if (pInStr[0] == '.') pOutString.push_back('0');
+
+    pOutString.push_back(pInStr[0]);
+    for (size_t ci = 1; ci < instr_len; ci++) {
+        if ((pInStr[ci] == '.') && ((pInStr[ci - 1] == ' ') || (pInStr[ci - 1] == '-') || (pInStr[ci - 1] == '+') || (pInStr[ci - 1] == '\t'))) {
+            pOutString.push_back('0');
+            pOutString.push_back('.');
+        } else {
+            pOutString.push_back(pInStr[ci]);
+        }
+    }
+}
+
+static bool ParseHelper_Decode_Base64_IsBase64(const char pChar) {
+    return (isalnum(pChar) || (pChar == '+') || (pChar == '/'));
+}
+
+void AMFImporter::ParseHelper_Decode_Base64(const std::string &pInputBase64, std::vector<uint8_t> &pOutputData) const {
+    // With help from
+    // René Nyffenegger http://www.adp-gmbh.ch/cpp/common/base64.html
+    const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+    uint8_t tidx = 0;
+    uint8_t arr4[4], arr3[3];
+
+    // check input data
+    if (pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
+    // prepare output place
+    pOutputData.clear();
+    pOutputData.reserve(pInputBase64.size() / 4 * 3);
+
+    for (size_t in_len = pInputBase64.size(), in_idx = 0; (in_len > 0) && (pInputBase64[in_idx] != '='); in_len--) {
+        if (ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx])) {
+            arr4[tidx++] = pInputBase64[in_idx++];
+            if (tidx == 4) {
+                for (tidx = 0; tidx < 4; tidx++)
+                    arr4[tidx] = (uint8_t)base64_chars.find(arr4[tidx]);
+
+                arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
+                arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
+                arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
+                for (tidx = 0; tidx < 3; tidx++)
+                    pOutputData.push_back(arr3[tidx]);
+
+                tidx = 0;
+            } // if(tidx == 4)
+        } // if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx]))
+        else {
+            in_idx++;
+        } // if(ParseHelper_Decode_Base64_IsBase64(pInputBase64[in_idx])) else
+    }
+
+    if (tidx) {
+        for (uint8_t i = tidx; i < 4; i++)
+            arr4[i] = 0;
+        for (uint8_t i = 0; i < 4; i++)
+            arr4[i] = (uint8_t)(base64_chars.find(arr4[i]));
+
+        arr3[0] = (arr4[0] << 2) + ((arr4[1] & 0x30) >> 4);
+        arr3[1] = ((arr4[1] & 0x0F) << 4) + ((arr4[2] & 0x3C) >> 2);
+        arr3[2] = ((arr4[2] & 0x03) << 6) + arr4[3];
+        for (uint8_t i = 0; i < (tidx - 1); i++)
+            pOutputData.push_back(arr3[i]);
+    }
+}
+
+void AMFImporter::ParseFile(const std::string &pFile, IOSystem *pIOHandler) {
+    irr::io::IrrXMLReader *OldReader = mReader; // store current XMLreader.
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
+
+    // Check whether we can read from the file
+    if (file.get() == NULL) throw DeadlyImportError("Failed to open AMF file " + pFile + ".");
+
+    // generate a XML reader for it
+    std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
+    mReader = irr::io::createIrrXMLReader(mIOWrapper.get());
+    if (!mReader) throw DeadlyImportError("Failed to create XML reader for file" + pFile + ".");
+    //
+    // start reading
+    // search for root tag <amf>
+    if (XML_SearchNode("amf"))
+        ParseNode_Root();
+    else
+        throw DeadlyImportError("Root node \"amf\" not found.");
+
+    delete mReader;
+    // restore old XMLreader
+    mReader = OldReader;
+}
+
+// <amf
+// unit="" - The units to be used. May be "inch", "millimeter", "meter", "feet", or "micron".
+// version="" - Version of file format.
+// >
+// </amf>
+// Root XML element.
+// Multi elements - No.
+void AMFImporter::ParseNode_Root() {
+    std::string unit, version;
+    CAMFImporter_NodeElement *ne(nullptr);
+
+    // Read attributes for node <amf>.
+    MACRO_ATTRREAD_LOOPBEG;
+    MACRO_ATTRREAD_CHECK_RET("unit", unit, mReader->getAttributeValue);
+    MACRO_ATTRREAD_CHECK_RET("version", version, mReader->getAttributeValue);
+    MACRO_ATTRREAD_LOOPEND_WSKIP;
+
+    // Check attributes
+    if (!mUnit.empty()) {
+        if ((mUnit != "inch") && (mUnit != "millimeter") && (mUnit != "meter") && (mUnit != "feet") && (mUnit != "micron")) Throw_IncorrectAttrValue("unit");
+    }
+
+    // create root node element.
+    ne = new CAMFImporter_NodeElement_Root(nullptr);
+    mNodeElement_Cur = ne; // set first "current" element
+    // and assign attribute's values
+    ((CAMFImporter_NodeElement_Root *)ne)->Unit = unit;
+    ((CAMFImporter_NodeElement_Root *)ne)->Version = version;
+
+    // Check for child nodes
+    if (!mReader->isEmptyElement()) {
+        MACRO_NODECHECK_LOOPBEGIN("amf");
+        if (XML_CheckNode_NameEqual("object")) {
+            ParseNode_Object();
+            continue;
+        }
+        if (XML_CheckNode_NameEqual("material")) {
+            ParseNode_Material();
+            continue;
+        }
+        if (XML_CheckNode_NameEqual("texture")) {
+            ParseNode_Texture();
+            continue;
+        }
+        if (XML_CheckNode_NameEqual("constellation")) {
+            ParseNode_Constellation();
+            continue;
+        }
+        if (XML_CheckNode_NameEqual("metadata")) {
+            ParseNode_Metadata();
+            continue;
+        }
+        MACRO_NODECHECK_LOOPEND("amf");
+        mNodeElement_Cur = ne; // force restore "current" element
+    } // if(!mReader->isEmptyElement())
+
+    mNodeElement_List.push_back(ne); // add to node element list because its a new object in graph.
+}
+
+// <constellation
+// id="" - The Object ID of the new constellation being defined.
+// >
+// </constellation>
+// A collection of objects or constellations with specific relative locations.
+// Multi elements - Yes.
+// Parent element - <amf>.
+void AMFImporter::ParseNode_Constellation() {
+    std::string id;
+    CAMFImporter_NodeElement *ne(nullptr);
+
+    // Read attributes for node <constellation>.
+    MACRO_ATTRREAD_LOOPBEG;
+    MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
+    MACRO_ATTRREAD_LOOPEND;
+
+    // create and if needed - define new grouping object.
+    ne = new CAMFImporter_NodeElement_Constellation(mNodeElement_Cur);
+
+    CAMFImporter_NodeElement_Constellation &als = *((CAMFImporter_NodeElement_Constellation *)ne); // alias for convenience
+
+    if (!id.empty()) als.ID = id;
+    // Check for child nodes
+    if (!mReader->isEmptyElement()) {
+        ParseHelper_Node_Enter(ne);
+        MACRO_NODECHECK_LOOPBEGIN("constellation");
+        if (XML_CheckNode_NameEqual("instance")) {
+            ParseNode_Instance();
+            continue;
+        }
+        if (XML_CheckNode_NameEqual("metadata")) {
+            ParseNode_Metadata();
+            continue;
+        }
+        MACRO_NODECHECK_LOOPEND("constellation");
+        ParseHelper_Node_Exit();
+    } // if(!mReader->isEmptyElement())
+    else {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    } // if(!mReader->isEmptyElement()) else
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <instance
+// objectid="" - The Object ID of the new constellation being defined.
+// >
+// </instance>
+// A collection of objects or constellations with specific relative locations.
+// Multi elements - Yes.
+// Parent element - <amf>.
+void AMFImporter::ParseNode_Instance() {
+    std::string objectid;
+    CAMFImporter_NodeElement *ne(nullptr);
+
+    // Read attributes for node <constellation>.
+    MACRO_ATTRREAD_LOOPBEG;
+    MACRO_ATTRREAD_CHECK_RET("objectid", objectid, mReader->getAttributeValue);
+    MACRO_ATTRREAD_LOOPEND;
+
+    // used object id must be defined, check that.
+    if (objectid.empty()) throw DeadlyImportError("\"objectid\" in <instance> must be defined.");
+    // create and define new grouping object.
+    ne = new CAMFImporter_NodeElement_Instance(mNodeElement_Cur);
+
+    CAMFImporter_NodeElement_Instance &als = *((CAMFImporter_NodeElement_Instance *)ne); // alias for convenience
+
+    als.ObjectID = objectid;
+    // Check for child nodes
+    if (!mReader->isEmptyElement()) {
+        bool read_flag[6] = { false, false, false, false, false, false };
+
+        als.Delta.Set(0, 0, 0);
+        als.Rotation.Set(0, 0, 0);
+        ParseHelper_Node_Enter(ne);
+        MACRO_NODECHECK_LOOPBEGIN("instance");
+        MACRO_NODECHECK_READCOMP_F("deltax", read_flag[0], als.Delta.x);
+        MACRO_NODECHECK_READCOMP_F("deltay", read_flag[1], als.Delta.y);
+        MACRO_NODECHECK_READCOMP_F("deltaz", read_flag[2], als.Delta.z);
+        MACRO_NODECHECK_READCOMP_F("rx", read_flag[3], als.Rotation.x);
+        MACRO_NODECHECK_READCOMP_F("ry", read_flag[4], als.Rotation.y);
+        MACRO_NODECHECK_READCOMP_F("rz", read_flag[5], als.Rotation.z);
+        MACRO_NODECHECK_LOOPEND("instance");
+        ParseHelper_Node_Exit();
+        // also convert degrees to radians.
+        als.Rotation.x = AI_MATH_PI_F * als.Rotation.x / 180.0f;
+        als.Rotation.y = AI_MATH_PI_F * als.Rotation.y / 180.0f;
+        als.Rotation.z = AI_MATH_PI_F * als.Rotation.z / 180.0f;
+    } // if(!mReader->isEmptyElement())
+    else {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    } // if(!mReader->isEmptyElement()) else
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <object
+// id="" - A unique ObjectID for the new object being defined.
+// >
+// </object>
+// An object definition.
+// Multi elements - Yes.
+// Parent element - <amf>.
+void AMFImporter::ParseNode_Object() {
+    std::string id;
+    CAMFImporter_NodeElement *ne(nullptr);
+
+    // Read attributes for node <object>.
+    MACRO_ATTRREAD_LOOPBEG;
+    MACRO_ATTRREAD_CHECK_RET("id", id, mReader->getAttributeValue);
+    MACRO_ATTRREAD_LOOPEND;
+
+    // create and if needed - define new geometry object.
+    ne = new CAMFImporter_NodeElement_Object(mNodeElement_Cur);
+
+    CAMFImporter_NodeElement_Object &als = *((CAMFImporter_NodeElement_Object *)ne); // alias for convenience
+
+    if (!id.empty()) als.ID = id;
+    // Check for child nodes
+    if (!mReader->isEmptyElement()) {
+        bool col_read = false;
+
+        ParseHelper_Node_Enter(ne);
+        MACRO_NODECHECK_LOOPBEGIN("object");
+        if (XML_CheckNode_NameEqual("color")) {
+            // Check if color already defined for object.
+            if (col_read) Throw_MoreThanOnceDefined("color", "Only one color can be defined for <object>.");
+            // read data and set flag about it
+            ParseNode_Color();
+            col_read = true;
+
+            continue;
+        }
+
+        if (XML_CheckNode_NameEqual("mesh")) {
+            ParseNode_Mesh();
+            continue;
+        }
+        if (XML_CheckNode_NameEqual("metadata")) {
+            ParseNode_Metadata();
+            continue;
+        }
+        MACRO_NODECHECK_LOOPEND("object");
+        ParseHelper_Node_Exit();
+    } // if(!mReader->isEmptyElement())
+    else {
+        mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    } // if(!mReader->isEmptyElement()) else
+
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+// <metadata
+// type="" - The type of the attribute.
+// >
+// </metadata>
+// Specify additional information about an entity.
+// Multi elements - Yes.
+// Parent element - <amf>, <object>, <volume>, <material>, <vertex>.
+//
+// Reserved types are:
+// "Name" - The alphanumeric label of the entity, to be used by the interpreter if interacting with the user.
+// "Description" - A description of the content of the entity
+// "URL" - A link to an external resource relating to the entity
+// "Author" - Specifies the name(s) of the author(s) of the entity
+// "Company" - Specifying the company generating the entity
+// "CAD" - specifies the name of the originating CAD software and version
+// "Revision" - specifies the revision of the entity
+// "Tolerance" - specifies the desired manufacturing tolerance of the entity in entity's unit system
+// "Volume" - specifies the total volume of the entity, in the entity's unit system, to be used for verification (object and volume only)
+void AMFImporter::ParseNode_Metadata() {
+    std::string type, value;
+    CAMFImporter_NodeElement *ne(nullptr);
+
+    // read attribute
+    MACRO_ATTRREAD_LOOPBEG;
+    MACRO_ATTRREAD_CHECK_RET("type", type, mReader->getAttributeValue);
+    MACRO_ATTRREAD_LOOPEND;
+    // and value of node.
+    value = mReader->getNodeData();
+    // Create node element and assign read data.
+    ne = new CAMFImporter_NodeElement_Metadata(mNodeElement_Cur);
+    ((CAMFImporter_NodeElement_Metadata *)ne)->Type = type;
+    ((CAMFImporter_NodeElement_Metadata *)ne)->Value = value;
+    mNodeElement_Cur->Child.push_back(ne); // Add element to child list of current element
+    mNodeElement_List.push_back(ne); // and to node element list because its a new object in graph.
+}
+
+/*********************************************************************************************************************************************/
+/******************************************************** Functions: BaseImporter set ********************************************************/
+/*********************************************************************************************************************************************/
+
+bool AMFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool pCheckSig) const {
+    const std::string extension = GetExtension(pFile);
+
+    if (extension == "amf") {
+        return true;
+    }
+
+    if (!extension.length() || pCheckSig) {
+        const char *tokens[] = { "<amf" };
+
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
+    }
+
+    return false;
+}
+
+void AMFImporter::GetExtensionList(std::set<std::string> &pExtensionList) {
+    pExtensionList.insert("amf");
+}
+
+const aiImporterDesc *AMFImporter::GetInfo() const {
+    return &Description;
+}
+
+void AMFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    Clear(); // delete old graph.
+    ParseFile(pFile, pIOHandler);
+    Postprocess_BuildScene(pScene);
+    // scene graph is ready, exit.
+}
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/code/AMF/AMFImporter.hpp b/code/AssetLib/AMF/AMFImporter.hpp
similarity index 100%
rename from code/AMF/AMFImporter.hpp
rename to code/AssetLib/AMF/AMFImporter.hpp
diff --git a/code/AMF/AMFImporter_Geometry.cpp b/code/AssetLib/AMF/AMFImporter_Geometry.cpp
similarity index 100%
rename from code/AMF/AMFImporter_Geometry.cpp
rename to code/AssetLib/AMF/AMFImporter_Geometry.cpp
diff --git a/code/AMF/AMFImporter_Macro.hpp b/code/AssetLib/AMF/AMFImporter_Macro.hpp
similarity index 100%
rename from code/AMF/AMFImporter_Macro.hpp
rename to code/AssetLib/AMF/AMFImporter_Macro.hpp
diff --git a/code/AMF/AMFImporter_Material.cpp b/code/AssetLib/AMF/AMFImporter_Material.cpp
similarity index 100%
rename from code/AMF/AMFImporter_Material.cpp
rename to code/AssetLib/AMF/AMFImporter_Material.cpp
diff --git a/code/AMF/AMFImporter_Node.hpp b/code/AssetLib/AMF/AMFImporter_Node.hpp
similarity index 100%
rename from code/AMF/AMFImporter_Node.hpp
rename to code/AssetLib/AMF/AMFImporter_Node.hpp
diff --git a/code/AssetLib/AMF/AMFImporter_Postprocess.cpp b/code/AssetLib/AMF/AMFImporter_Postprocess.cpp
new file mode 100644
index 000000000..596b0235c
--- /dev/null
+++ b/code/AssetLib/AMF/AMFImporter_Postprocess.cpp
@@ -0,0 +1,872 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 AMFImporter_Postprocess.cpp
+/// \brief Convert built scenegraph and objects to Assimp scenegraph.
+/// \date 2016
+/// \author smal.root@gmail.com
+
+#ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
+
+#include "AMFImporter.hpp"
+
+// Header files, Assimp.
+#include <assimp/SceneCombiner.h>
+#include <assimp/StandardShapes.h>
+#include <assimp/StringUtils.h>
+
+// Header files, stdlib.
+#include <iterator>
+
+namespace Assimp {
+
+aiColor4D AMFImporter::SPP_Material::GetColor(const float /*pX*/, const float /*pY*/, const float /*pZ*/) const {
+    aiColor4D tcol;
+
+    // Check if stored data are supported.
+    if (!Composition.empty()) {
+        throw DeadlyImportError("IME. GetColor for composition");
+    } else if (Color->Composed) {
+        throw DeadlyImportError("IME. GetColor, composed color");
+    } else {
+        tcol = Color->Color;
+    }
+
+    // Check if default color must be used
+    if ((tcol.r == 0) && (tcol.g == 0) && (tcol.b == 0) && (tcol.a == 0)) {
+        tcol.r = 0.5f;
+        tcol.g = 0.5f;
+        tcol.b = 0.5f;
+        tcol.a = 1;
+    }
+
+    return tcol;
+}
+
+void AMFImporter::PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh &pNodeElement, std::vector<aiVector3D> &pVertexCoordinateArray,
+        std::vector<CAMFImporter_NodeElement_Color *> &pVertexColorArray) const {
+    CAMFImporter_NodeElement_Vertices *vn = nullptr;
+    size_t col_idx;
+
+    // All data stored in "vertices", search for it.
+    for (CAMFImporter_NodeElement *ne_child : pNodeElement.Child) {
+        if (ne_child->Type == CAMFImporter_NodeElement::ENET_Vertices) vn = (CAMFImporter_NodeElement_Vertices *)ne_child;
+    }
+
+    // If "vertices" not found then no work for us.
+    if (vn == nullptr) return;
+
+    pVertexCoordinateArray.reserve(vn->Child.size()); // all coordinates stored as child and we need to reserve space for future push_back's.
+    pVertexColorArray.resize(vn->Child.size()); // colors count equal vertices count.
+    col_idx = 0;
+    // Inside vertices collect all data and place to arrays
+    for (CAMFImporter_NodeElement *vn_child : vn->Child) {
+        // vertices, colors
+        if (vn_child->Type == CAMFImporter_NodeElement::ENET_Vertex) {
+            // by default clear color for current vertex
+            pVertexColorArray[col_idx] = nullptr;
+
+            for (CAMFImporter_NodeElement *vtx : vn_child->Child) {
+                if (vtx->Type == CAMFImporter_NodeElement::ENET_Coordinates) {
+                    pVertexCoordinateArray.push_back(((CAMFImporter_NodeElement_Coordinates *)vtx)->Coordinate);
+
+                    continue;
+                }
+
+                if (vtx->Type == CAMFImporter_NodeElement::ENET_Color) {
+                    pVertexColorArray[col_idx] = (CAMFImporter_NodeElement_Color *)vtx;
+
+                    continue;
+                }
+            } // for(CAMFImporter_NodeElement* vtx: vn_child->Child)
+
+            col_idx++;
+        } // if(vn_child->Type == CAMFImporter_NodeElement::ENET_Vertex)
+    } // for(CAMFImporter_NodeElement* vn_child: vn->Child)
+}
+
+size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string &pID_R, const std::string &pID_G, const std::string &pID_B,
+        const std::string &pID_A) {
+    size_t TextureConverted_Index;
+    std::string TextureConverted_ID;
+
+    // check input data
+    if (pID_R.empty() && pID_G.empty() && pID_B.empty() && pID_A.empty())
+        throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. At least one texture ID must be defined.");
+
+    // Create ID
+    TextureConverted_ID = pID_R + "_" + pID_G + "_" + pID_B + "_" + pID_A;
+    // Check if texture specified by set of IDs is converted already.
+    TextureConverted_Index = 0;
+    for (const SPP_Texture &tex_convd : mTexture_Converted) {
+        if (tex_convd.ID == TextureConverted_ID) {
+            return TextureConverted_Index;
+        } else {
+            ++TextureConverted_Index;
+        }
+    }
+
+    //
+    // Converted texture not found, create it.
+    //
+    CAMFImporter_NodeElement_Texture *src_texture[4]{ nullptr };
+    std::vector<CAMFImporter_NodeElement_Texture *> src_texture_4check;
+    SPP_Texture converted_texture;
+
+    { // find all specified source textures
+        CAMFImporter_NodeElement *t_tex;
+
+        // R
+        if (!pID_R.empty()) {
+            if (!Find_NodeElement(pID_R, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_R);
+
+            src_texture[0] = (CAMFImporter_NodeElement_Texture *)t_tex;
+            src_texture_4check.push_back((CAMFImporter_NodeElement_Texture *)t_tex);
+        } else {
+            src_texture[0] = nullptr;
+        }
+
+        // G
+        if (!pID_G.empty()) {
+            if (!Find_NodeElement(pID_G, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_G);
+
+            src_texture[1] = (CAMFImporter_NodeElement_Texture *)t_tex;
+            src_texture_4check.push_back((CAMFImporter_NodeElement_Texture *)t_tex);
+        } else {
+            src_texture[1] = nullptr;
+        }
+
+        // B
+        if (!pID_B.empty()) {
+            if (!Find_NodeElement(pID_B, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_B);
+
+            src_texture[2] = (CAMFImporter_NodeElement_Texture *)t_tex;
+            src_texture_4check.push_back((CAMFImporter_NodeElement_Texture *)t_tex);
+        } else {
+            src_texture[2] = nullptr;
+        }
+
+        // A
+        if (!pID_A.empty()) {
+            if (!Find_NodeElement(pID_A, CAMFImporter_NodeElement::ENET_Texture, &t_tex)) Throw_ID_NotFound(pID_A);
+
+            src_texture[3] = (CAMFImporter_NodeElement_Texture *)t_tex;
+            src_texture_4check.push_back((CAMFImporter_NodeElement_Texture *)t_tex);
+        } else {
+            src_texture[3] = nullptr;
+        }
+    } // END: find all specified source textures
+
+    // check that all textures has same size
+    if (src_texture_4check.size() > 1) {
+        for (size_t i = 0, i_e = (src_texture_4check.size() - 1); i < i_e; i++) {
+            if ((src_texture_4check[i]->Width != src_texture_4check[i + 1]->Width) || (src_texture_4check[i]->Height != src_texture_4check[i + 1]->Height) ||
+                    (src_texture_4check[i]->Depth != src_texture_4check[i + 1]->Depth)) {
+                throw DeadlyImportError("PostprocessHelper_GetTextureID_Or_Create. Source texture must has the same size.");
+            }
+        }
+    } // if(src_texture_4check.size() > 1)
+
+    // set texture attributes
+    converted_texture.Width = src_texture_4check[0]->Width;
+    converted_texture.Height = src_texture_4check[0]->Height;
+    converted_texture.Depth = src_texture_4check[0]->Depth;
+    // if one of source texture is tiled then converted texture is tiled too.
+    converted_texture.Tiled = false;
+    for (uint8_t i = 0; i < src_texture_4check.size(); i++)
+        converted_texture.Tiled |= src_texture_4check[i]->Tiled;
+
+    // Create format hint.
+    strcpy(converted_texture.FormatHint, "rgba0000"); // copy initial string.
+    if (!pID_R.empty()) converted_texture.FormatHint[4] = '8';
+    if (!pID_G.empty()) converted_texture.FormatHint[5] = '8';
+    if (!pID_B.empty()) converted_texture.FormatHint[6] = '8';
+    if (!pID_A.empty()) converted_texture.FormatHint[7] = '8';
+
+    //
+    // Сopy data of textures.
+    //
+    size_t tex_size = 0;
+    size_t step = 0;
+    size_t off_g = 0;
+    size_t off_b = 0;
+
+    // Calculate size of the target array and rule how data will be copied.
+    if (!pID_R.empty() && nullptr != src_texture[0]) {
+        tex_size += src_texture[0]->Data.size();
+        step++, off_g++, off_b++;
+    }
+    if (!pID_G.empty() && nullptr != src_texture[1]) {
+        tex_size += src_texture[1]->Data.size();
+        step++, off_b++;
+    }
+    if (!pID_B.empty() && nullptr != src_texture[2]) {
+        tex_size += src_texture[2]->Data.size();
+        step++;
+    }
+    if (!pID_A.empty() && nullptr != src_texture[3]) {
+        tex_size += src_texture[3]->Data.size();
+        step++;
+    }
+
+    // Create target array.
+    converted_texture.Data = new uint8_t[tex_size];
+    // And copy data
+    auto CopyTextureData = [&](const std::string &pID, const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void {
+        if (!pID.empty()) {
+            for (size_t idx_target = pOffset, idx_src = 0; idx_target < tex_size; idx_target += pStep, idx_src++) {
+                CAMFImporter_NodeElement_Texture *tex = src_texture[pSrcTexNum];
+                ai_assert(tex);
+                converted_texture.Data[idx_target] = tex->Data.at(idx_src);
+            }
+        }
+    }; // auto CopyTextureData = [&](const size_t pOffset, const size_t pStep, const uint8_t pSrcTexNum) -> void
+
+    CopyTextureData(pID_R, 0, step, 0);
+    CopyTextureData(pID_G, off_g, step, 1);
+    CopyTextureData(pID_B, off_b, step, 2);
+    CopyTextureData(pID_A, step - 1, step, 3);
+
+    // Store new converted texture ID
+    converted_texture.ID = TextureConverted_ID;
+    // Store new converted texture
+    mTexture_Converted.push_back(converted_texture);
+
+    return TextureConverted_Index;
+}
+
+void AMFImporter::PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace> &pInputList, std::list<std::list<SComplexFace>> &pOutputList_Separated) {
+    auto texmap_is_equal = [](const CAMFImporter_NodeElement_TexMap *pTexMap1, const CAMFImporter_NodeElement_TexMap *pTexMap2) -> bool {
+        if ((pTexMap1 == nullptr) && (pTexMap2 == nullptr)) return true;
+        if (pTexMap1 == nullptr) return false;
+        if (pTexMap2 == nullptr) return false;
+
+        if (pTexMap1->TextureID_R != pTexMap2->TextureID_R) return false;
+        if (pTexMap1->TextureID_G != pTexMap2->TextureID_G) return false;
+        if (pTexMap1->TextureID_B != pTexMap2->TextureID_B) return false;
+        if (pTexMap1->TextureID_A != pTexMap2->TextureID_A) return false;
+
+        return true;
+    };
+
+    pOutputList_Separated.clear();
+    if (pInputList.empty()) return;
+
+    do {
+        SComplexFace face_start = pInputList.front();
+        std::list<SComplexFace> face_list_cur;
+
+        for (std::list<SComplexFace>::iterator it = pInputList.begin(), it_end = pInputList.end(); it != it_end;) {
+            if (texmap_is_equal(face_start.TexMap, it->TexMap)) {
+                auto it_old = it;
+
+                ++it;
+                face_list_cur.push_back(*it_old);
+                pInputList.erase(it_old);
+            } else {
+                ++it;
+            }
+        }
+
+        if (!face_list_cur.empty()) pOutputList_Separated.push_back(face_list_cur);
+
+    } while (!pInputList.empty());
+}
+
+void AMFImporter::Postprocess_AddMetadata(const std::list<CAMFImporter_NodeElement_Metadata *> &metadataList, aiNode &sceneNode) const {
+    if (!metadataList.empty()) {
+        if (sceneNode.mMetaData != nullptr) throw DeadlyImportError("Postprocess. MetaData member in node are not nullptr. Something went wrong.");
+
+        // copy collected metadata to output node.
+        sceneNode.mMetaData = aiMetadata::Alloc(static_cast<unsigned int>(metadataList.size()));
+        size_t meta_idx(0);
+
+        for (const CAMFImporter_NodeElement_Metadata &metadata : metadataList) {
+            sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata.Type, aiString(metadata.Value));
+        }
+    } // if(!metadataList.empty())
+}
+
+void AMFImporter::Postprocess_BuildNodeAndObject(const CAMFImporter_NodeElement_Object &pNodeElement, std::list<aiMesh *> &pMeshList, aiNode **pSceneNode) {
+    CAMFImporter_NodeElement_Color *object_color = nullptr;
+
+    // create new aiNode and set name as <object> has.
+    *pSceneNode = new aiNode;
+    (*pSceneNode)->mName = pNodeElement.ID;
+    // read mesh and color
+    for (const CAMFImporter_NodeElement *ne_child : pNodeElement.Child) {
+        std::vector<aiVector3D> vertex_arr;
+        std::vector<CAMFImporter_NodeElement_Color *> color_arr;
+
+        // color for object
+        if (ne_child->Type == CAMFImporter_NodeElement::ENET_Color) object_color = (CAMFImporter_NodeElement_Color *)ne_child;
+
+        if (ne_child->Type == CAMFImporter_NodeElement::ENET_Mesh) {
+            // Create arrays from children of mesh: vertices.
+            PostprocessHelper_CreateMeshDataArray(*((CAMFImporter_NodeElement_Mesh *)ne_child), vertex_arr, color_arr);
+            // Use this arrays as a source when creating every aiMesh
+            Postprocess_BuildMeshSet(*((CAMFImporter_NodeElement_Mesh *)ne_child), vertex_arr, color_arr, object_color, pMeshList, **pSceneNode);
+        }
+    } // for(const CAMFImporter_NodeElement* ne_child: pNodeElement)
+}
+
+void AMFImporter::Postprocess_BuildMeshSet(const CAMFImporter_NodeElement_Mesh &pNodeElement, const std::vector<aiVector3D> &pVertexCoordinateArray,
+        const std::vector<CAMFImporter_NodeElement_Color *> &pVertexColorArray,
+        const CAMFImporter_NodeElement_Color *pObjectColor, std::list<aiMesh *> &pMeshList, aiNode &pSceneNode) {
+    std::list<unsigned int> mesh_idx;
+
+    // all data stored in "volume", search for it.
+    for (const CAMFImporter_NodeElement *ne_child : pNodeElement.Child) {
+        const CAMFImporter_NodeElement_Color *ne_volume_color = nullptr;
+        const SPP_Material *cur_mat = nullptr;
+
+        if (ne_child->Type == CAMFImporter_NodeElement::ENET_Volume) {
+            /******************* Get faces *******************/
+            const CAMFImporter_NodeElement_Volume *ne_volume = reinterpret_cast<const CAMFImporter_NodeElement_Volume *>(ne_child);
+
+            std::list<SComplexFace> complex_faces_list; // List of the faces of the volume.
+            std::list<std::list<SComplexFace>> complex_faces_toplist; // List of the face list for every mesh.
+
+            // check if volume use material
+            if (!ne_volume->MaterialID.empty()) {
+                if (!Find_ConvertedMaterial(ne_volume->MaterialID, &cur_mat)) Throw_ID_NotFound(ne_volume->MaterialID);
+            }
+
+            // inside "volume" collect all data and place to arrays or create new objects
+            for (const CAMFImporter_NodeElement *ne_volume_child : ne_volume->Child) {
+                // color for volume
+                if (ne_volume_child->Type == CAMFImporter_NodeElement::ENET_Color) {
+                    ne_volume_color = reinterpret_cast<const CAMFImporter_NodeElement_Color *>(ne_volume_child);
+                } else if (ne_volume_child->Type == CAMFImporter_NodeElement::ENET_Triangle) // triangles, triangles colors
+                {
+                    const CAMFImporter_NodeElement_Triangle &tri_al = *reinterpret_cast<const CAMFImporter_NodeElement_Triangle *>(ne_volume_child);
+
+                    SComplexFace complex_face;
+
+                    // initialize pointers
+                    complex_face.Color = nullptr;
+                    complex_face.TexMap = nullptr;
+                    // get data from triangle children: color, texture coordinates.
+                    if (tri_al.Child.size()) {
+                        for (const CAMFImporter_NodeElement *ne_triangle_child : tri_al.Child) {
+                            if (ne_triangle_child->Type == CAMFImporter_NodeElement::ENET_Color)
+                                complex_face.Color = reinterpret_cast<const CAMFImporter_NodeElement_Color *>(ne_triangle_child);
+                            else if (ne_triangle_child->Type == CAMFImporter_NodeElement::ENET_TexMap)
+                                complex_face.TexMap = reinterpret_cast<const CAMFImporter_NodeElement_TexMap *>(ne_triangle_child);
+                        }
+                    } // if(tri_al.Child.size())
+
+                    // create new face and store it.
+                    complex_face.Face.mNumIndices = 3;
+                    complex_face.Face.mIndices = new unsigned int[3];
+                    complex_face.Face.mIndices[0] = static_cast<unsigned int>(tri_al.V[0]);
+                    complex_face.Face.mIndices[1] = static_cast<unsigned int>(tri_al.V[1]);
+                    complex_face.Face.mIndices[2] = static_cast<unsigned int>(tri_al.V[2]);
+                    complex_faces_list.push_back(complex_face);
+                }
+            } // for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
+
+            /**** Split faces list: one list per mesh ****/
+            PostprocessHelper_SplitFacesByTextureID(complex_faces_list, complex_faces_toplist);
+
+            /***** Create mesh for every faces list ******/
+            for (std::list<SComplexFace> &face_list_cur : complex_faces_toplist) {
+                auto VertexIndex_GetMinimal = [](const std::list<SComplexFace> &pFaceList, const size_t *pBiggerThan) -> size_t {
+                    size_t rv = 0;
+
+                    if (pBiggerThan != nullptr) {
+                        bool found = false;
+
+                        for (const SComplexFace &face : pFaceList) {
+                            for (size_t idx_vert = 0; idx_vert < face.Face.mNumIndices; idx_vert++) {
+                                if (face.Face.mIndices[idx_vert] > *pBiggerThan) {
+                                    rv = face.Face.mIndices[idx_vert];
+                                    found = true;
+
+                                    break;
+                                }
+                            }
+
+                            if (found) break;
+                        }
+
+                        if (!found) return *pBiggerThan;
+                    } else {
+                        rv = pFaceList.front().Face.mIndices[0];
+                    } // if(pBiggerThan != nullptr) else
+
+                    for (const SComplexFace &face : pFaceList) {
+                        for (size_t vi = 0; vi < face.Face.mNumIndices; vi++) {
+                            if (face.Face.mIndices[vi] < rv) {
+                                if (pBiggerThan != nullptr) {
+                                    if (face.Face.mIndices[vi] > *pBiggerThan) rv = face.Face.mIndices[vi];
+                                } else {
+                                    rv = face.Face.mIndices[vi];
+                                }
+                            }
+                        }
+                    } // for(const SComplexFace& face: pFaceList)
+
+                    return rv;
+                }; // auto VertexIndex_GetMinimal = [](const std::list<SComplexFace>& pFaceList, const size_t* pBiggerThan) -> size_t
+
+                auto VertexIndex_Replace = [](std::list<SComplexFace> &pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void {
+                    for (const SComplexFace &face : pFaceList) {
+                        for (size_t vi = 0; vi < face.Face.mNumIndices; vi++) {
+                            if (face.Face.mIndices[vi] == pIdx_From) face.Face.mIndices[vi] = static_cast<unsigned int>(pIdx_To);
+                        }
+                    }
+                }; // auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
+
+                auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D {
+                    // Color priorities(In descending order):
+                    // 1. triangle color;
+                    // 2. vertex color;
+                    // 3. volume color;
+                    // 4. object color;
+                    // 5. material;
+                    // 6. default - invisible coat.
+                    //
+                    // Fill vertices colors in color priority list above that's points from 1 to 6.
+                    if ((pIdx < pVertexColorArray.size()) && (pVertexColorArray[pIdx] != nullptr)) // check for vertex color
+                    {
+                        if (pVertexColorArray[pIdx]->Composed)
+                            throw DeadlyImportError("IME: vertex color composed");
+                        else
+                            return pVertexColorArray[pIdx]->Color;
+                    } else if (ne_volume_color != nullptr) // check for volume color
+                    {
+                        if (ne_volume_color->Composed)
+                            throw DeadlyImportError("IME: volume color composed");
+                        else
+                            return ne_volume_color->Color;
+                    } else if (pObjectColor != nullptr) // check for object color
+                    {
+                        if (pObjectColor->Composed)
+                            throw DeadlyImportError("IME: object color composed");
+                        else
+                            return pObjectColor->Color;
+                    } else if (cur_mat != nullptr) // check for material
+                    {
+                        return cur_mat->GetColor(pVertexCoordinateArray.at(pIdx).x, pVertexCoordinateArray.at(pIdx).y, pVertexCoordinateArray.at(pIdx).z);
+                    } else // set default color.
+                    {
+                        return { 0, 0, 0, 0 };
+                    } // if((vi < pVertexColorArray.size()) && (pVertexColorArray[vi] != nullptr)) else
+                }; // auto Vertex_CalculateColor = [&](const size_t pIdx) -> aiColor4D
+
+                aiMesh *tmesh = new aiMesh;
+
+                tmesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; // Only triangles is supported by AMF.
+                //
+                // set geometry and colors (vertices)
+                //
+                // copy faces/triangles
+                tmesh->mNumFaces = static_cast<unsigned int>(face_list_cur.size());
+                tmesh->mFaces = new aiFace[tmesh->mNumFaces];
+
+                // Create vertices list and optimize indices. Optimisation mean following.In AMF all volumes use one big list of vertices. And one volume
+                // can use only part of vertices list, for example: vertices list contain few thousands of vertices and volume use vertices 1, 3, 10.
+                // Do you need all this thousands of garbage? Of course no. So, optimisation step transformate sparse indices set to continuous.
+                size_t VertexCount_Max = tmesh->mNumFaces * 3; // 3 - triangles.
+                std::vector<aiVector3D> vert_arr, texcoord_arr;
+                std::vector<aiColor4D> col_arr;
+
+                vert_arr.reserve(VertexCount_Max * 2); // "* 2" - see below TODO.
+                col_arr.reserve(VertexCount_Max * 2);
+
+                { // fill arrays
+                    size_t vert_idx_from, vert_idx_to;
+
+                    // first iteration.
+                    vert_idx_to = 0;
+                    vert_idx_from = VertexIndex_GetMinimal(face_list_cur, nullptr);
+                    vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
+                    col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
+                    if (vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
+
+                    // rest iterations
+                    do {
+                        vert_idx_from = VertexIndex_GetMinimal(face_list_cur, &vert_idx_to);
+                        if (vert_idx_from == vert_idx_to) break; // all indices are transferred,
+
+                        vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
+                        col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
+                        vert_idx_to++;
+                        if (vert_idx_from != vert_idx_to) VertexIndex_Replace(face_list_cur, vert_idx_from, vert_idx_to);
+
+                    } while (true);
+                } // fill arrays. END.
+
+                //
+                // check if triangle colors are used and create additional faces if needed.
+                //
+                for (const SComplexFace &face_cur : face_list_cur) {
+                    if (face_cur.Color != nullptr) {
+                        aiColor4D face_color;
+                        size_t vert_idx_new = vert_arr.size();
+
+                        if (face_cur.Color->Composed)
+                            throw DeadlyImportError("IME: face color composed");
+                        else
+                            face_color = face_cur.Color->Color;
+
+                        for (size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++) {
+                            vert_arr.push_back(vert_arr.at(face_cur.Face.mIndices[idx_ind]));
+                            col_arr.push_back(face_color);
+                            face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(vert_idx_new++);
+                        }
+                    } // if(face_cur.Color != nullptr)
+                } // for(const SComplexFace& face_cur: face_list_cur)
+
+                //
+                // if texture is used then copy texture coordinates too.
+                //
+                if (face_list_cur.front().TexMap != nullptr) {
+                    size_t idx_vert_new = vert_arr.size();
+                    ///TODO: clean unused vertices. "* 2": in certain cases - mesh full of triangle colors - vert_arr will contain duplicated vertices for
+                    /// colored triangles and initial vertices (for colored vertices) which in real became unused. This part need more thinking about
+                    /// optimisation.
+                    bool *idx_vert_used;
+
+                    idx_vert_used = new bool[VertexCount_Max * 2];
+                    for (size_t i = 0, i_e = VertexCount_Max * 2; i < i_e; i++)
+                        idx_vert_used[i] = false;
+
+                    // This ID's will be used when set materials ID in scene.
+                    tmesh->mMaterialIndex = static_cast<unsigned int>(PostprocessHelper_GetTextureID_Or_Create(face_list_cur.front().TexMap->TextureID_R,
+                            face_list_cur.front().TexMap->TextureID_G,
+                            face_list_cur.front().TexMap->TextureID_B,
+                            face_list_cur.front().TexMap->TextureID_A));
+                    texcoord_arr.resize(VertexCount_Max * 2);
+                    for (const SComplexFace &face_cur : face_list_cur) {
+                        for (size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++) {
+                            const size_t idx_vert = face_cur.Face.mIndices[idx_ind];
+
+                            if (!idx_vert_used[idx_vert]) {
+                                texcoord_arr.at(idx_vert) = face_cur.TexMap->TextureCoordinate[idx_ind];
+                                idx_vert_used[idx_vert] = true;
+                            } else if (texcoord_arr.at(idx_vert) != face_cur.TexMap->TextureCoordinate[idx_ind]) {
+                                // in that case one vertex is shared with many texture coordinates. We need to duplicate vertex with another texture
+                                // coordinates.
+                                vert_arr.push_back(vert_arr.at(idx_vert));
+                                col_arr.push_back(col_arr.at(idx_vert));
+                                texcoord_arr.at(idx_vert_new) = face_cur.TexMap->TextureCoordinate[idx_ind];
+                                face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(idx_vert_new++);
+                            }
+                        } // for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
+                    } // for(const SComplexFace& face_cur: face_list_cur)
+
+                    delete[] idx_vert_used;
+                    // shrink array
+                    texcoord_arr.resize(idx_vert_new);
+                } // if(face_list_cur.front().TexMap != nullptr)
+
+                //
+                // copy collected data to mesh
+                //
+                tmesh->mNumVertices = static_cast<unsigned int>(vert_arr.size());
+                tmesh->mVertices = new aiVector3D[tmesh->mNumVertices];
+                tmesh->mColors[0] = new aiColor4D[tmesh->mNumVertices];
+
+                memcpy(tmesh->mVertices, vert_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
+                memcpy(tmesh->mColors[0], col_arr.data(), tmesh->mNumVertices * sizeof(aiColor4D));
+                if (texcoord_arr.size() > 0) {
+                    tmesh->mTextureCoords[0] = new aiVector3D[tmesh->mNumVertices];
+                    memcpy(tmesh->mTextureCoords[0], texcoord_arr.data(), tmesh->mNumVertices * sizeof(aiVector3D));
+                    tmesh->mNumUVComponents[0] = 2; // U and V stored in "x", "y" of aiVector3D.
+                }
+
+                size_t idx_face = 0;
+                for (const SComplexFace &face_cur : face_list_cur)
+                    tmesh->mFaces[idx_face++] = face_cur.Face;
+
+                // store new aiMesh
+                mesh_idx.push_back(static_cast<unsigned int>(pMeshList.size()));
+                pMeshList.push_back(tmesh);
+            } // for(const std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
+        } // if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
+    } // for(const CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
+
+    // if meshes was created then assign new indices with current aiNode
+    if (!mesh_idx.empty()) {
+        std::list<unsigned int>::const_iterator mit = mesh_idx.begin();
+
+        pSceneNode.mNumMeshes = static_cast<unsigned int>(mesh_idx.size());
+        pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
+        for (size_t i = 0; i < pSceneNode.mNumMeshes; i++)
+            pSceneNode.mMeshes[i] = *mit++;
+    } // if(mesh_idx.size() > 0)
+}
+
+void AMFImporter::Postprocess_BuildMaterial(const CAMFImporter_NodeElement_Material &pMaterial) {
+    SPP_Material new_mat;
+
+    new_mat.ID = pMaterial.ID;
+    for (const CAMFImporter_NodeElement *mat_child : pMaterial.Child) {
+        if (mat_child->Type == CAMFImporter_NodeElement::ENET_Color) {
+            new_mat.Color = (CAMFImporter_NodeElement_Color *)mat_child;
+        } else if (mat_child->Type == CAMFImporter_NodeElement::ENET_Metadata) {
+            new_mat.Metadata.push_back((CAMFImporter_NodeElement_Metadata *)mat_child);
+        }
+    } // for(const CAMFImporter_NodeElement* mat_child; pMaterial.Child)
+
+    // place converted material to special list
+    mMaterial_Converted.push_back(new_mat);
+}
+
+void AMFImporter::Postprocess_BuildConstellation(CAMFImporter_NodeElement_Constellation &pConstellation, std::list<aiNode *> &pNodeList) const {
+    aiNode *con_node;
+    std::list<aiNode *> ch_node;
+
+    // We will build next hierarchy:
+    // aiNode as parent (<constellation>) for set of nodes as a children
+    //  |- aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
+    //  ...
+    //  \_ aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
+    con_node = new aiNode;
+    con_node->mName = pConstellation.ID;
+    // Walk through children and search for instances of another objects, constellations.
+    for (const CAMFImporter_NodeElement *ne : pConstellation.Child) {
+        aiMatrix4x4 tmat;
+        aiNode *t_node;
+        aiNode *found_node;
+
+        if (ne->Type == CAMFImporter_NodeElement::ENET_Metadata) continue;
+        if (ne->Type != CAMFImporter_NodeElement::ENET_Instance) throw DeadlyImportError("Only <instance> nodes can be in <constellation>.");
+
+        // create alias for conveniance
+        CAMFImporter_NodeElement_Instance &als = *((CAMFImporter_NodeElement_Instance *)ne);
+        // find referenced object
+        if (!Find_ConvertedNode(als.ObjectID, pNodeList, &found_node)) Throw_ID_NotFound(als.ObjectID);
+
+        // create node for applying transformation
+        t_node = new aiNode;
+        t_node->mParent = con_node;
+        // apply transformation
+        aiMatrix4x4::Translation(als.Delta, tmat), t_node->mTransformation *= tmat;
+        aiMatrix4x4::RotationX(als.Rotation.x, tmat), t_node->mTransformation *= tmat;
+        aiMatrix4x4::RotationY(als.Rotation.y, tmat), t_node->mTransformation *= tmat;
+        aiMatrix4x4::RotationZ(als.Rotation.z, tmat), t_node->mTransformation *= tmat;
+        // create array for one child node
+        t_node->mNumChildren = 1;
+        t_node->mChildren = new aiNode *[t_node->mNumChildren];
+        SceneCombiner::Copy(&t_node->mChildren[0], found_node);
+        t_node->mChildren[0]->mParent = t_node;
+        ch_node.push_back(t_node);
+    } // for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
+
+    // copy found aiNode's as children
+    if (ch_node.empty()) throw DeadlyImportError("<constellation> must have at least one <instance>.");
+
+    size_t ch_idx = 0;
+
+    con_node->mNumChildren = static_cast<unsigned int>(ch_node.size());
+    con_node->mChildren = new aiNode *[con_node->mNumChildren];
+    for (aiNode *node : ch_node)
+        con_node->mChildren[ch_idx++] = node;
+
+    // and place "root" of <constellation> node to node list
+    pNodeList.push_back(con_node);
+}
+
+void AMFImporter::Postprocess_BuildScene(aiScene *pScene) {
+    std::list<aiNode *> node_list;
+    std::list<aiMesh *> mesh_list;
+    std::list<CAMFImporter_NodeElement_Metadata *> meta_list;
+
+    //
+    // Because for AMF "material" is just complex colors mixing so aiMaterial will not be used.
+    // For building aiScene we are must to do few steps:
+    // at first creating root node for aiScene.
+    pScene->mRootNode = new aiNode;
+    pScene->mRootNode->mParent = nullptr;
+    pScene->mFlags |= AI_SCENE_FLAGS_ALLOW_SHARED;
+    // search for root(<amf>) element
+    CAMFImporter_NodeElement *root_el = nullptr;
+
+    for (CAMFImporter_NodeElement *ne : mNodeElement_List) {
+        if (ne->Type != CAMFImporter_NodeElement::ENET_Root) continue;
+
+        root_el = ne;
+
+        break;
+    } // for(const CAMFImporter_NodeElement* ne: mNodeElement_List)
+
+    // Check if root element are found.
+    if (root_el == nullptr) throw DeadlyImportError("Root(<amf>) element not found.");
+
+    // after that walk through children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
+    // <constellation> and <metadata>. But at first we must read <material> and <texture> because they will be used in <object>. <metadata> can be read
+    // at any moment.
+    //
+    // 1. <material>
+    // 2. <texture> will be converted later when processing triangles list. \sa Postprocess_BuildMeshSet
+    for (const CAMFImporter_NodeElement *root_child : root_el->Child) {
+        if (root_child->Type == CAMFImporter_NodeElement::ENET_Material) Postprocess_BuildMaterial(*((CAMFImporter_NodeElement_Material *)root_child));
+    }
+
+    // After "appearance" nodes we must read <object> because it will be used in <constellation> -> <instance>.
+    //
+    // 3. <object>
+    for (const CAMFImporter_NodeElement *root_child : root_el->Child) {
+        if (root_child->Type == CAMFImporter_NodeElement::ENET_Object) {
+            aiNode *tnode = nullptr;
+
+            // for <object> mesh and node must be built: object ID assigned to aiNode name and will be used in future for <instance>
+            Postprocess_BuildNodeAndObject(*((CAMFImporter_NodeElement_Object *)root_child), mesh_list, &tnode);
+            if (tnode != nullptr) node_list.push_back(tnode);
+        }
+    } // for(const CAMFImporter_NodeElement* root_child: root_el->Child)
+
+    // And finally read rest of nodes.
+    //
+    for (const CAMFImporter_NodeElement *root_child : root_el->Child) {
+        // 4. <constellation>
+        if (root_child->Type == CAMFImporter_NodeElement::ENET_Constellation) {
+            // <object> and <constellation> at top of self abstraction use aiNode. So we can use only aiNode list for creating new aiNode's.
+            Postprocess_BuildConstellation(*((CAMFImporter_NodeElement_Constellation *)root_child), node_list);
+        }
+
+        // 5, <metadata>
+        if (root_child->Type == CAMFImporter_NodeElement::ENET_Metadata) meta_list.push_back((CAMFImporter_NodeElement_Metadata *)root_child);
+    } // for(const CAMFImporter_NodeElement* root_child: root_el->Child)
+
+    // at now we can add collected metadata to root node
+    Postprocess_AddMetadata(meta_list, *pScene->mRootNode);
+    //
+    // Check constellation children
+    //
+    // As said in specification:
+    // "When multiple objects and constellations are defined in a single file, only the top level objects and constellations are available for printing."
+    // What that means? For example: if some object is used in constellation then you must show only constellation but not original object.
+    // And at this step we are checking that relations.
+nl_clean_loop:
+
+    if (node_list.size() > 1) {
+        // walk through all nodes
+        for (std::list<aiNode *>::iterator nl_it = node_list.begin(); nl_it != node_list.end(); ++nl_it) {
+            // and try to find them in another top nodes.
+            std::list<aiNode *>::const_iterator next_it = nl_it;
+
+            ++next_it;
+            for (; next_it != node_list.end(); ++next_it) {
+                if ((*next_it)->FindNode((*nl_it)->mName) != nullptr) {
+                    // if current top node(nl_it) found in another top node then erase it from node_list and restart search loop.
+                    node_list.erase(nl_it);
+
+                    goto nl_clean_loop;
+                }
+            } // for(; next_it != node_list.end(); next_it++)
+        } // for(std::list<aiNode*>::const_iterator nl_it = node_list.begin(); nl_it != node_list.end(); nl_it++)
+    }
+
+    //
+    // move created objects to aiScene
+    //
+    //
+    // Nodes
+    if (!node_list.empty()) {
+        std::list<aiNode *>::const_iterator nl_it = node_list.begin();
+
+        pScene->mRootNode->mNumChildren = static_cast<unsigned int>(node_list.size());
+        pScene->mRootNode->mChildren = new aiNode *[pScene->mRootNode->mNumChildren];
+        for (size_t i = 0; i < pScene->mRootNode->mNumChildren; i++) {
+            // Objects and constellation that must be showed placed at top of hierarchy in <amf> node. So all aiNode's in node_list must have
+            // mRootNode only as parent.
+            (*nl_it)->mParent = pScene->mRootNode;
+            pScene->mRootNode->mChildren[i] = *nl_it++;
+        }
+    } // if(node_list.size() > 0)
+
+    //
+    // Meshes
+    if (!mesh_list.empty()) {
+        std::list<aiMesh *>::const_iterator ml_it = mesh_list.begin();
+
+        pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
+        pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+        for (size_t i = 0; i < pScene->mNumMeshes; i++)
+            pScene->mMeshes[i] = *ml_it++;
+    } // if(mesh_list.size() > 0)
+
+    //
+    // Textures
+    pScene->mNumTextures = static_cast<unsigned int>(mTexture_Converted.size());
+    if (pScene->mNumTextures > 0) {
+        size_t idx;
+
+        idx = 0;
+        pScene->mTextures = new aiTexture *[pScene->mNumTextures];
+        for (const SPP_Texture &tex_convd : mTexture_Converted) {
+            pScene->mTextures[idx] = new aiTexture;
+            pScene->mTextures[idx]->mWidth = static_cast<unsigned int>(tex_convd.Width);
+            pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
+            pScene->mTextures[idx]->pcData = (aiTexel *)tex_convd.Data;
+            // texture format description.
+            strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
+            idx++;
+        } // for(const SPP_Texture& tex_convd: mTexture_Converted)
+
+        // Create materials for embedded textures.
+        idx = 0;
+        pScene->mNumMaterials = static_cast<unsigned int>(mTexture_Converted.size());
+        pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+        for (const SPP_Texture &tex_convd : mTexture_Converted) {
+            const aiString texture_id(AI_EMBEDDED_TEXNAME_PREFIX + to_string(idx));
+            const int mode = aiTextureOp_Multiply;
+            const int repeat = tex_convd.Tiled ? 1 : 0;
+
+            pScene->mMaterials[idx] = new aiMaterial;
+            pScene->mMaterials[idx]->AddProperty(&texture_id, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            pScene->mMaterials[idx]->AddProperty(&mode, 1, AI_MATKEY_TEXOP_DIFFUSE(0));
+            pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_U_DIFFUSE(0));
+            pScene->mMaterials[idx]->AddProperty(&repeat, 1, AI_MATKEY_MAPPINGMODE_V_DIFFUSE(0));
+            idx++;
+        }
+    } // if(pScene->mNumTextures > 0)
+} // END: after that walk through children of root and collect data
+
+} // namespace Assimp
+
+#endif // !ASSIMP_BUILD_NO_AMF_IMPORTER
diff --git a/code/ASE/ASELoader.cpp b/code/AssetLib/ASE/ASELoader.cpp
similarity index 64%
rename from code/ASE/ASELoader.cpp
rename to code/AssetLib/ASE/ASELoader.cpp
index b2155d5e5..47b357248 100644
--- a/code/ASE/ASELoader.cpp
+++ b/code/AssetLib/ASE/ASELoader.cpp
@@ -51,15 +51,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // internal headers
 #include "ASELoader.h"
-#include <assimp/StringComparison.h>
-#include <assimp/SkeletonMeshBuilder.h>
 #include "Common/TargetAnimation.h"
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/StringComparison.h>
 
-#include <assimp/Importer.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 
 #include <memory>
 
@@ -84,12 +84,8 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-ASEImporter::ASEImporter()
-: mParser()
-, mBuffer()
-, pcScene()
-, configRecomputeNormals()
-, noSkeletonMesh() {
+ASEImporter::ASEImporter() :
+        mParser(), mBuffer(), pcScene(), configRecomputeNormals(), noSkeletonMesh() {
     // empty
 }
 
@@ -101,7 +97,7 @@ ASEImporter::~ASEImporter() {
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const {
+bool ASEImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool cs) const {
     // check file extension
     const std::string extension = GetExtension(pFile);
 
@@ -110,41 +106,43 @@ bool ASEImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool
     }
 
     if ((!extension.length() || cs) && pIOHandler) {
-        const char* tokens[] = {"*3dsmax_asciiexport"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
+        const char *tokens[] = { "*3dsmax_asciiexport" };
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
     }
     return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader meta information
-const aiImporterDesc* ASEImporter::GetInfo () const {
+const aiImporterDesc *ASEImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration options
-void ASEImporter::SetupProperties(const Importer* pImp) {
+void ASEImporter::SetupProperties(const Importer *pImp) {
     configRecomputeNormals = (pImp->GetPropertyInteger(
-        AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS,1) ? true : false);
+                                      AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS, 1) ?
+                                      true :
+                                      false);
 
-    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void ASEImporter::InternReadFile( const std::string& pFile,
-    aiScene* pScene, IOSystem* pIOHandler) {
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+void ASEImporter::InternReadFile(const std::string &pFile,
+        aiScene *pScene, IOSystem *pIOHandler) {
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if( file.get() == nullptr) {
-        throw DeadlyImportError( "Failed to open ASE file " + pFile + ".");
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open ASE file " + pFile + ".");
     }
 
     // Allocate storage and copy the contents of the file to a memory buffer
     std::vector<char> mBuffer2;
-    TextFileToBuffer(file.get(),mBuffer2);
+    TextFileToBuffer(file.get(), mBuffer2);
 
     this->mBuffer = &mBuffer2[0];
     this->pcScene = pScene;
@@ -155,8 +153,8 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // ASE is the actual version 200 (that is currently written by max)
     // ------------------------------------------------------------------
     unsigned int defaultFormat;
-    std::string::size_type s = pFile.length()-1;
-    switch (pFile.c_str()[s])   {
+    std::string::size_type s = pFile.length() - 1;
+    switch (pFile.c_str()[s]) {
 
     case 'C':
     case 'c':
@@ -167,7 +165,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     };
 
     // Construct an ASE parser and parse the file
-    ASE::Parser parser(mBuffer,defaultFormat);
+    ASE::Parser parser(mBuffer, defaultFormat);
     mParser = &parser;
     mParser->Parse();
 
@@ -175,7 +173,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // Check whether we god at least one mesh. If we did - generate
     // materials and copy meshes.
     // ------------------------------------------------------------------
-    if ( !mParser->m_vMeshes.empty())   {
+    if (!mParser->m_vMeshes.empty()) {
 
         // If absolutely no material has been loaded from the file
         // we need to generate a default material
@@ -183,32 +181,32 @@ void ASEImporter::InternReadFile( const std::string& pFile,
 
         // process all meshes
         bool tookNormals = false;
-        std::vector<aiMesh*> avOutMeshes;
-        avOutMeshes.reserve(mParser->m_vMeshes.size()*2);
-        for (std::vector<ASE::Mesh>::iterator i =  mParser->m_vMeshes.begin();i != mParser->m_vMeshes.end();++i)    {
+        std::vector<aiMesh *> avOutMeshes;
+        avOutMeshes.reserve(mParser->m_vMeshes.size() * 2);
+        for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {
             if ((*i).bSkip) {
                 continue;
             }
             BuildUniqueRepresentation(*i);
 
             // Need to generate proper vertex normals if necessary
-            if(GenerateNormals(*i)) {
+            if (GenerateNormals(*i)) {
                 tookNormals = true;
             }
 
             // Convert all meshes to aiMesh objects
-            ConvertMeshes(*i,avOutMeshes);
+            ConvertMeshes(*i, avOutMeshes);
         }
-        if (tookNormals)    {
+        if (tookNormals) {
             ASSIMP_LOG_DEBUG("ASE: Taking normals from the file. Use "
-                "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "
-                "experience problems");
+                             "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "
+                             "experience problems");
         }
 
         // Now build the output mesh list. Remove dummies
         pScene->mNumMeshes = (unsigned int)avOutMeshes.size();
-        aiMesh** pp = pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
-        for (std::vector<aiMesh*>::const_iterator i =  avOutMeshes.begin();i != avOutMeshes.end();++i) {
+        aiMesh **pp = pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+        for (std::vector<aiMesh *>::const_iterator i = avOutMeshes.begin(); i != avOutMeshes.end(); ++i) {
             if (!(*i)->mNumFaces) {
                 continue;
             }
@@ -225,18 +223,21 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // Copy all scene graph nodes - lights, cameras, dummies and meshes
     // into one huge list.
     //------------------------------------------------------------------
-    std::vector<BaseNode*> nodes;
-    nodes.reserve(mParser->m_vMeshes.size() +mParser->m_vLights.size()
-        + mParser->m_vCameras.size() + mParser->m_vDummies.size());
+    std::vector<BaseNode *> nodes;
+    nodes.reserve(mParser->m_vMeshes.size() + mParser->m_vLights.size() + mParser->m_vCameras.size() + mParser->m_vDummies.size());
 
     // Lights
-    for (auto &light : mParser->m_vLights)nodes.push_back(&light);
+    for (auto &light : mParser->m_vLights)
+        nodes.push_back(&light);
     // Cameras
-    for (auto &camera : mParser->m_vCameras)nodes.push_back(&camera);
+    for (auto &camera : mParser->m_vCameras)
+        nodes.push_back(&camera);
     // Meshes
-    for (auto &mesh : mParser->m_vMeshes)nodes.push_back(&mesh);
+    for (auto &mesh : mParser->m_vMeshes)
+        nodes.push_back(&mesh);
     // Dummies
-    for (auto &dummy : mParser->m_vDummies)nodes.push_back(&dummy);
+    for (auto &dummy : mParser->m_vDummies)
+        nodes.push_back(&dummy);
 
     // build the final node graph
     BuildNodes(nodes);
@@ -255,7 +256,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     // to build a mesh for the animation skeleton
     // FIXME: very strange results
     // ------------------------------------------------------------------
-    if (!pScene->mNumMeshes)    {
+    if (!pScene->mNumMeshes) {
         pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
         if (!noSkeletonMesh) {
             SkeletonMeshBuilder skeleton(pScene);
@@ -263,82 +264,80 @@ void ASEImporter::InternReadFile( const std::string& pFile,
     }
 }
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::GenerateDefaultMaterial()
-{
-    ai_assert(NULL != mParser);
+void ASEImporter::GenerateDefaultMaterial() {
+    ai_assert(nullptr != mParser);
 
     bool bHas = false;
-    for (std::vector<ASE::Mesh>::iterator i =  mParser->m_vMeshes.begin();i != mParser->m_vMeshes.end();++i) {
-        if ((*i).bSkip)continue;
+    for (std::vector<ASE::Mesh>::iterator i = mParser->m_vMeshes.begin(); i != mParser->m_vMeshes.end(); ++i) {
+        if ((*i).bSkip) continue;
         if (ASE::Face::DEFAULT_MATINDEX == (*i).iMaterialIndex) {
             (*i).iMaterialIndex = (unsigned int)mParser->m_vMaterials.size();
             bHas = true;
         }
     }
-    if (bHas || mParser->m_vMaterials.empty())  {
+    if (bHas || mParser->m_vMaterials.empty()) {
         // add a simple material without submaterials to the parser's list
-        mParser->m_vMaterials.push_back ( ASE::Material(AI_DEFAULT_MATERIAL_NAME) );
-        ASE::Material& mat = mParser->m_vMaterials.back();
+        mParser->m_vMaterials.push_back(ASE::Material(AI_DEFAULT_MATERIAL_NAME));
+        ASE::Material &mat = mParser->m_vMaterials.back();
 
-        mat.mDiffuse  = aiColor3D(0.6f,0.6f,0.6f);
-        mat.mSpecular = aiColor3D(1.0f,1.0f,1.0f);
-        mat.mAmbient  = aiColor3D(0.05f,0.05f,0.05f);
-        mat.mShading  = Discreet3DS::Gouraud;
+        mat.mDiffuse = aiColor3D(0.6f, 0.6f, 0.6f);
+        mat.mSpecular = aiColor3D(1.0f, 1.0f, 1.0f);
+        mat.mAmbient = aiColor3D(0.05f, 0.05f, 0.05f);
+        mat.mShading = Discreet3DS::Gouraud;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
-{
+void ASEImporter::BuildAnimations(const std::vector<BaseNode *> &nodes) {
     // check whether we have at least one mesh which has animations
-    std::vector<ASE::BaseNode*>::const_iterator i =  nodes.begin();
+    std::vector<ASE::BaseNode *>::const_iterator i = nodes.begin();
     unsigned int iNum = 0;
-    for (;i != nodes.end();++i) {
+    for (; i != nodes.end(); ++i) {
 
         // TODO: Implement Bezier & TCB support
         if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) {
             ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
-                "This is not supported.");
+                            "This is not supported.");
         }
         if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) {
             ASSIMP_LOG_WARN("ASE: Rotation controller uses Bezier/TCB keys. "
-                "This is not supported.");
+                            "This is not supported.");
         }
-        if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK)  {
+        if ((*i)->mAnim.mScalingType != ASE::Animation::TRACK) {
             ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
-                "This is not supported.");
+                            "This is not supported.");
         }
 
         // We compare against 1 here - firstly one key is not
         // really an animation and secondly MAX writes dummies
         // that represent the node transformation.
-        if ((*i)->mAnim.akeyPositions.size()>1 || (*i)->mAnim.akeyRotations.size()>1 || (*i)->mAnim.akeyScaling.size()>1){
+        if ((*i)->mAnim.akeyPositions.size() > 1 || (*i)->mAnim.akeyRotations.size() > 1 || (*i)->mAnim.akeyScaling.size() > 1) {
             ++iNum;
         }
-        if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan( (*i)->mTargetPosition.x )) {
+        if ((*i)->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan((*i)->mTargetPosition.x)) {
             ++iNum;
         }
     }
-    if (iNum)   {
+    if (iNum) {
         // Generate a new animation channel and setup everything for it
         pcScene->mNumAnimations = 1;
-        pcScene->mAnimations    = new aiAnimation*[1];
-        aiAnimation* pcAnim     = pcScene->mAnimations[0] = new aiAnimation();
-        pcAnim->mNumChannels    = iNum;
-        pcAnim->mChannels       = new aiNodeAnim*[iNum];
+        pcScene->mAnimations = new aiAnimation *[1];
+        aiAnimation *pcAnim = pcScene->mAnimations[0] = new aiAnimation();
+        pcAnim->mNumChannels = iNum;
+        pcAnim->mChannels = new aiNodeAnim *[iNum];
         pcAnim->mTicksPerSecond = mParser->iFrameSpeed * mParser->iTicksPerFrame;
 
         iNum = 0;
 
         // Now iterate through all meshes and collect all data we can find
-        for (i =  nodes.begin();i != nodes.end();++i)   {
+        for (i = nodes.begin(); i != nodes.end(); ++i) {
 
-            ASE::BaseNode* me = *i;
-            if ( me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan( me->mTargetPosition.x ))  {
+            ASE::BaseNode *me = *i;
+            if (me->mTargetAnim.akeyPositions.size() > 1 && is_not_qnan(me->mTargetPosition.x)) {
                 // Generate an extra channel for the camera/light target.
                 // BuildNodes() does also generate an extra node, named
                 // <baseName>.Target.
-                aiNodeAnim* nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
+                aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
                 nd->mNodeName.Set(me->mName + ".Target");
 
                 // If there is no input position channel we will need
@@ -357,32 +356,31 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
                 helper.Process(&me->mTargetAnim.akeyPositions);*/
 
                 // Allocate the key array and fill it
-                nd->mNumPositionKeys = (unsigned int) me->mTargetAnim.akeyPositions.size();
+                nd->mNumPositionKeys = (unsigned int)me->mTargetAnim.akeyPositions.size();
                 nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
 
-                ::memcpy(nd->mPositionKeys,&me->mTargetAnim.akeyPositions[0],
-                    nd->mNumPositionKeys * sizeof(aiVectorKey));
+                ::memcpy(nd->mPositionKeys, &me->mTargetAnim.akeyPositions[0],
+                        nd->mNumPositionKeys * sizeof(aiVectorKey));
             }
 
-            if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1)   {
+            if (me->mAnim.akeyPositions.size() > 1 || me->mAnim.akeyRotations.size() > 1 || me->mAnim.akeyScaling.size() > 1) {
                 // Begin a new node animation channel for this node
-                aiNodeAnim* nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
+                aiNodeAnim *nd = pcAnim->mChannels[iNum++] = new aiNodeAnim();
                 nd->mNodeName.Set(me->mName);
 
                 // copy position keys
-                if (me->mAnim.akeyPositions.size() > 1 )
-                {
+                if (me->mAnim.akeyPositions.size() > 1) {
                     // Allocate the key array and fill it
-                    nd->mNumPositionKeys = (unsigned int) me->mAnim.akeyPositions.size();
+                    nd->mNumPositionKeys = (unsigned int)me->mAnim.akeyPositions.size();
                     nd->mPositionKeys = new aiVectorKey[nd->mNumPositionKeys];
 
-                    ::memcpy(nd->mPositionKeys,&me->mAnim.akeyPositions[0],
-                        nd->mNumPositionKeys * sizeof(aiVectorKey));
+                    ::memcpy(nd->mPositionKeys, &me->mAnim.akeyPositions[0],
+                            nd->mNumPositionKeys * sizeof(aiVectorKey));
                 }
                 // copy rotation keys
-                if (me->mAnim.akeyRotations.size() > 1 )    {
+                if (me->mAnim.akeyRotations.size() > 1) {
                     // Allocate the key array and fill it
-                    nd->mNumRotationKeys = (unsigned int) me->mAnim.akeyRotations.size();
+                    nd->mNumRotationKeys = (unsigned int)me->mAnim.akeyRotations.size();
                     nd->mRotationKeys = new aiQuatKey[nd->mNumRotationKeys];
 
                     // --------------------------------------------------------------------
@@ -395,11 +393,11 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
                     // --------------------------------------------------------------------
 
                     aiQuaternion cur;
-                    for (unsigned int a = 0; a < nd->mNumRotationKeys;++a)  {
+                    for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) {
                         aiQuatKey q = me->mAnim.akeyRotations[a];
 
                         if (mParser->iFileFormat > 110) {
-                            cur = (a ? cur*q.mValue : q.mValue);
+                            cur = (a ? cur * q.mValue : q.mValue);
                             q.mValue = cur.Normalize();
                         }
                         nd->mRotationKeys[a] = q;
@@ -409,13 +407,13 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
                     }
                 }
                 // copy scaling keys
-                if (me->mAnim.akeyScaling.size() > 1 )  {
+                if (me->mAnim.akeyScaling.size() > 1) {
                     // Allocate the key array and fill it
-                    nd->mNumScalingKeys = (unsigned int) me->mAnim.akeyScaling.size();
+                    nd->mNumScalingKeys = (unsigned int)me->mAnim.akeyScaling.size();
                     nd->mScalingKeys = new aiVectorKey[nd->mNumScalingKeys];
 
-                    ::memcpy(nd->mScalingKeys,&me->mAnim.akeyScaling[0],
-                        nd->mNumScalingKeys * sizeof(aiVectorKey));
+                    ::memcpy(nd->mScalingKeys, &me->mAnim.akeyScaling[0],
+                            nd->mNumScalingKeys * sizeof(aiVectorKey));
                 }
             }
         }
@@ -424,18 +422,17 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
 
 // ------------------------------------------------------------------------------------------------
 // Build output cameras
-void ASEImporter::BuildCameras()
-{
-    if (!mParser->m_vCameras.empty())   {
+void ASEImporter::BuildCameras() {
+    if (!mParser->m_vCameras.empty()) {
         pcScene->mNumCameras = (unsigned int)mParser->m_vCameras.size();
-        pcScene->mCameras = new aiCamera*[pcScene->mNumCameras];
+        pcScene->mCameras = new aiCamera *[pcScene->mNumCameras];
 
-        for (unsigned int i = 0; i < pcScene->mNumCameras;++i)  {
-            aiCamera* out = pcScene->mCameras[i] = new aiCamera();
-            ASE::Camera& in = mParser->m_vCameras[i];
+        for (unsigned int i = 0; i < pcScene->mNumCameras; ++i) {
+            aiCamera *out = pcScene->mCameras[i] = new aiCamera();
+            ASE::Camera &in = mParser->m_vCameras[i];
 
             // copy members
-            out->mClipPlaneFar  = in.mFar;
+            out->mClipPlaneFar = in.mFar;
             out->mClipPlaneNear = (in.mNear ? in.mNear : 0.1f);
             out->mHorizontalFOV = in.mFOV;
 
@@ -446,24 +443,22 @@ void ASEImporter::BuildCameras()
 
 // ------------------------------------------------------------------------------------------------
 // Build output lights
-void ASEImporter::BuildLights()
-{
-    if (!mParser->m_vLights.empty())    {
+void ASEImporter::BuildLights() {
+    if (!mParser->m_vLights.empty()) {
         pcScene->mNumLights = (unsigned int)mParser->m_vLights.size();
-        pcScene->mLights    = new aiLight*[pcScene->mNumLights];
+        pcScene->mLights = new aiLight *[pcScene->mNumLights];
 
-        for (unsigned int i = 0; i < pcScene->mNumLights;++i)   {
-            aiLight* out = pcScene->mLights[i] = new aiLight();
-            ASE::Light& in = mParser->m_vLights[i];
+        for (unsigned int i = 0; i < pcScene->mNumLights; ++i) {
+            aiLight *out = pcScene->mLights[i] = new aiLight();
+            ASE::Light &in = mParser->m_vLights[i];
 
             // The direction is encoded in the transformation matrix of the node.
             // In 3DS MAX the light source points into negative Z direction if
             // the node transformation is the identity.
-            out->mDirection = aiVector3D(0.f,0.f,-1.f);
+            out->mDirection = aiVector3D(0.f, 0.f, -1.f);
 
             out->mName.Set(in.mName);
-            switch (in.mLightType)
-            {
+            switch (in.mLightType) {
             case ASE::Light::TARGET:
                 out->mType = aiLightSource_SPOT;
                 out->mAngleInnerCone = AI_DEG_TO_RAD(in.mAngle);
@@ -475,7 +470,7 @@ void ASEImporter::BuildLights()
                 break;
 
             default:
-            //case ASE::Light::OMNI:
+                //case ASE::Light::OMNI:
                 out->mType = aiLightSource_POINT;
                 break;
             };
@@ -485,57 +480,55 @@ void ASEImporter::BuildLights()
 }
 
 // ------------------------------------------------------------------------------------------------
-void ASEImporter::AddNodes(const std::vector<BaseNode*>& nodes,
-    aiNode* pcParent,const char* szName)
-{
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
+        aiNode *pcParent, const char *szName) {
     aiMatrix4x4 m;
-    AddNodes(nodes,pcParent,szName,m);
+    AddNodes(nodes, pcParent, szName, m);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Add meshes to a given node
-void ASEImporter::AddMeshes(const ASE::BaseNode* snode,aiNode* node)
-{
-    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)   {
+void ASEImporter::AddMeshes(const ASE::BaseNode *snode, aiNode *node) {
+    for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
         // Get the name of the mesh (the mesh instance has been temporarily stored in the third vertex color)
-        const aiMesh* pcMesh  = pcScene->mMeshes[i];
-        const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2];
+        const aiMesh *pcMesh = pcScene->mMeshes[i];
+        const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];
 
         if (mesh == snode) {
             ++node->mNumMeshes;
         }
     }
 
-    if(node->mNumMeshes)    {
+    if (node->mNumMeshes) {
         node->mMeshes = new unsigned int[node->mNumMeshes];
-        for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes;++i)    {
+        for (unsigned int i = 0, p = 0; i < pcScene->mNumMeshes; ++i) {
 
-            const aiMesh* pcMesh  = pcScene->mMeshes[i];
-            const ASE::Mesh* mesh = (const ASE::Mesh*)pcMesh->mColors[2];
-            if (mesh == snode)  {
+            const aiMesh *pcMesh = pcScene->mMeshes[i];
+            const ASE::Mesh *mesh = (const ASE::Mesh *)pcMesh->mColors[2];
+            if (mesh == snode) {
                 node->mMeshes[p++] = i;
 
                 // Transform all vertices of the mesh back into their local space ->
                 // at the moment they are pretransformed
-                aiMatrix4x4 m  = mesh->mTransform;
+                aiMatrix4x4 m = mesh->mTransform;
                 m.Inverse();
 
-                aiVector3D* pvCurPtr = pcMesh->mVertices;
-                const aiVector3D* pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
-                while (pvCurPtr != pvEndPtr)    {
+                aiVector3D *pvCurPtr = pcMesh->mVertices;
+                const aiVector3D *pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
+                while (pvCurPtr != pvEndPtr) {
                     *pvCurPtr = m * (*pvCurPtr);
                     pvCurPtr++;
                 }
 
                 // Do the same for the normal vectors, if we have them.
                 // As always, inverse transpose.
-                if (pcMesh->mNormals)   {
-                    aiMatrix3x3 m3 = aiMatrix3x3( mesh->mTransform );
+                if (pcMesh->mNormals) {
+                    aiMatrix3x3 m3 = aiMatrix3x3(mesh->mTransform);
                     m3.Transpose();
 
                     pvCurPtr = pcMesh->mNormals;
                     pvEndPtr = pvCurPtr + pcMesh->mNumVertices;
-                    while (pvCurPtr != pvEndPtr)    {
+                    while (pvCurPtr != pvEndPtr) {
                         *pvCurPtr = m3 * (*pvCurPtr);
                         pvCurPtr++;
                     }
@@ -547,68 +540,65 @@ void ASEImporter::AddMeshes(const ASE::BaseNode* snode,aiNode* node)
 
 // ------------------------------------------------------------------------------------------------
 // Add child nodes to a given parent node
-void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
-    aiNode* pcParent, const char* szName,
-    const aiMatrix4x4& mat)
-{
+void ASEImporter::AddNodes(const std::vector<BaseNode *> &nodes,
+        aiNode *pcParent, const char *szName,
+        const aiMatrix4x4 &mat) {
     const size_t len = szName ? ::strlen(szName) : 0;
     ai_assert(4 <= AI_MAX_NUMBER_OF_COLOR_SETS);
 
     // Receives child nodes for the pcParent node
-    std::vector<aiNode*> apcNodes;
+    std::vector<aiNode *> apcNodes;
 
     // Now iterate through all nodes in the scene and search for one
     // which has *us* as parent.
-    for (std::vector<BaseNode*>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
-        const BaseNode* snode = *it;
+    for (std::vector<BaseNode *>::const_iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
+        const BaseNode *snode = *it;
         if (szName) {
-            if (len != snode->mParent.length() || ::strcmp(szName,snode->mParent.c_str()))
+            if (len != snode->mParent.length() || ::strcmp(szName, snode->mParent.c_str()))
                 continue;
-        }
-        else if (snode->mParent.length())
+        } else if (snode->mParent.length())
             continue;
 
         (*it)->mProcessed = true;
 
         // Allocate a new node and add it to the output data structure
         apcNodes.push_back(new aiNode());
-        aiNode* node = apcNodes.back();
+        aiNode *node = apcNodes.back();
 
         node->mName.Set((snode->mName.length() ? snode->mName.c_str() : "Unnamed_Node"));
         node->mParent = pcParent;
 
         // Setup the transformation matrix of the node
-        aiMatrix4x4 mParentAdjust  = mat;
+        aiMatrix4x4 mParentAdjust = mat;
         mParentAdjust.Inverse();
-        node->mTransformation = mParentAdjust*snode->mTransform;
+        node->mTransformation = mParentAdjust * snode->mTransform;
 
         // Add sub nodes - prevent stack overflow due to recursive parenting
-        if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName ) {
-            AddNodes(nodes,node,node->mName.data,snode->mTransform);
+        if (node->mName != node->mParent->mName && node->mName != node->mParent->mParent->mName) {
+            AddNodes(nodes, node, node->mName.data, snode->mTransform);
         }
 
         // Further processing depends on the type of the node
-        if (snode->mType == ASE::BaseNode::Mesh)    {
+        if (snode->mType == ASE::BaseNode::Mesh) {
             // If the type of this node is "Mesh" we need to search
             // the list of output meshes in the data structure for
             // all those that belonged to this node once. This is
             // slightly inconvinient here and a better solution should
             // be used when this code is refactored next.
-            AddMeshes(snode,node);
-        }
-        else if (is_not_qnan( snode->mTargetPosition.x ))   {
+            AddMeshes(snode, node);
+        } else if (is_not_qnan(snode->mTargetPosition.x)) {
             // If this is a target camera or light we generate a small
             // child node which marks the position of the camera
             // target (the direction information is contained in *this*
             // node's animation track but the exact target position
             // would be lost otherwise)
-            if (!node->mNumChildren)    {
-                node->mChildren = new aiNode*[1];
+            if (!node->mNumChildren) {
+                node->mChildren = new aiNode *[1];
             }
 
-            aiNode* nd = new aiNode();
+            aiNode *nd = new aiNode();
 
-            nd->mName.Set ( snode->mName + ".Target" );
+            nd->mName.Set(snode->mName + ".Target");
 
             nd->mTransformation.a4 = snode->mTargetPosition.x - snode->mTransform.a4;
             nd->mTransformation.b4 = snode->mTargetPosition.y - snode->mTransform.b4;
@@ -617,14 +607,14 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
             nd->mParent = node;
 
             // The .Target node is always the first child node
-            for (unsigned int m = 0; m < node->mNumChildren;++m)
-                node->mChildren[m+1] = node->mChildren[m];
+            for (unsigned int m = 0; m < node->mNumChildren; ++m)
+                node->mChildren[m + 1] = node->mChildren[m];
 
             node->mChildren[0] = nd;
             node->mNumChildren++;
 
             // What we did is so great, it is at least worth a debug message
-            ASSIMP_LOG_DEBUG("ASE: Generating separate target node ("+snode->mName+")");
+            ASSIMP_LOG_DEBUG("ASE: Generating separate target node (" + snode->mName + ")");
         }
     }
 
@@ -632,10 +622,10 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
     // We allocate one slot more  in case this is a target camera/light
     pcParent->mNumChildren = (unsigned int)apcNodes.size();
     if (pcParent->mNumChildren) {
-        pcParent->mChildren = new aiNode*[apcNodes.size()+1 /* PLUS ONE !!! */];
+        pcParent->mChildren = new aiNode *[apcNodes.size() + 1 /* PLUS ONE !!! */];
 
         // now build all nodes for our nice new children
-        for (unsigned int p = 0; p < apcNodes.size();++p)
+        for (unsigned int p = 0; p < apcNodes.size(); ++p)
             pcParent->mChildren[p] = apcNodes[p];
     }
     return;
@@ -643,32 +633,32 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
 
 // ------------------------------------------------------------------------------------------------
 // Build the output node graph
-void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
-    ai_assert(NULL != pcScene);
+void ASEImporter::BuildNodes(std::vector<BaseNode *> &nodes) {
+    ai_assert(nullptr != pcScene);
 
     // allocate the one and only root node
-    aiNode* root = pcScene->mRootNode = new aiNode();
+    aiNode *root = pcScene->mRootNode = new aiNode();
     root->mName.Set("<ASERoot>");
 
     // Setup the coordinate system transformation
     pcScene->mRootNode->mNumChildren = 1;
-    pcScene->mRootNode->mChildren = new aiNode*[1];
-    aiNode* ch = pcScene->mRootNode->mChildren[0] = new aiNode();
+    pcScene->mRootNode->mChildren = new aiNode *[1];
+    aiNode *ch = pcScene->mRootNode->mChildren[0] = new aiNode();
     ch->mParent = root;
 
     // Change the transformation matrix of all nodes
     for (BaseNode *node : nodes) {
-        aiMatrix4x4& m = node->mTransform;
+        aiMatrix4x4 &m = node->mTransform;
         m.Transpose(); // row-order vs column-order
     }
 
     // add all nodes
-    AddNodes(nodes,ch,NULL);
+    AddNodes(nodes, ch, nullptr);
 
     // now iterate through al nodes and find those that have not yet
     // been added to the nodegraph (= their parent could not be recognized)
-    std::vector<const BaseNode*> aiList;
-    for (std::vector<BaseNode*>::iterator it = nodes.begin(), end = nodes.end();it != end; ++it)    {
+    std::vector<const BaseNode *> aiList;
+    for (std::vector<BaseNode *>::iterator it = nodes.begin(), end = nodes.end(); it != end; ++it) {
         if ((*it)->mProcessed) {
             continue;
         }
@@ -678,54 +668,54 @@ void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
 
         // search the list another time, starting *here* and try to find out whether
         // there is a node that references *us* as a parent
-        for (std::vector<BaseNode*>::const_iterator it2 = nodes.begin();it2 != end; ++it2) {
+        for (std::vector<BaseNode *>::const_iterator it2 = nodes.begin(); it2 != end; ++it2) {
             if (it2 == it) {
                 continue;
             }
 
-            if ((*it2)->mName == (*it)->mParent)    {
+            if ((*it2)->mName == (*it)->mParent) {
                 bKnowParent = true;
                 break;
             }
         }
-        if (!bKnowParent)   {
+        if (!bKnowParent) {
             aiList.push_back(*it);
         }
     }
 
     // Are there ane orphaned nodes?
-    if (!aiList.empty())    {
-        std::vector<aiNode*> apcNodes;
+    if (!aiList.empty()) {
+        std::vector<aiNode *> apcNodes;
         apcNodes.reserve(aiList.size() + pcScene->mRootNode->mNumChildren);
 
-        for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren;++i)
+        for (unsigned int i = 0; i < pcScene->mRootNode->mNumChildren; ++i)
             apcNodes.push_back(pcScene->mRootNode->mChildren[i]);
 
         delete[] pcScene->mRootNode->mChildren;
-        for (std::vector<const BaseNode*>::/*const_*/iterator i =  aiList.begin();i != aiList.end();++i)    {
-            const ASE::BaseNode* src = *i;
+        for (std::vector<const BaseNode *>::/*const_*/ iterator i = aiList.begin(); i != aiList.end(); ++i) {
+            const ASE::BaseNode *src = *i;
 
             // The parent is not known, so we can assume that we must add
             // this node to the root node of the whole scene
-            aiNode* pcNode = new aiNode();
+            aiNode *pcNode = new aiNode();
             pcNode->mParent = pcScene->mRootNode;
             pcNode->mName.Set(src->mName);
-            AddMeshes(src,pcNode);
-            AddNodes(nodes,pcNode,pcNode->mName.data);
+            AddMeshes(src, pcNode);
+            AddNodes(nodes, pcNode, pcNode->mName.data);
             apcNodes.push_back(pcNode);
         }
 
         // Regenerate our output array
-        pcScene->mRootNode->mChildren = new aiNode*[apcNodes.size()];
-        for (unsigned int i = 0; i < apcNodes.size();++i)
+        pcScene->mRootNode->mChildren = new aiNode *[apcNodes.size()];
+        for (unsigned int i = 0; i < apcNodes.size(); ++i)
             pcScene->mRootNode->mChildren[i] = apcNodes[i];
 
         pcScene->mRootNode->mNumChildren = (unsigned int)apcNodes.size();
     }
 
-    // Reset the third color set to NULL - we used this field to store a temporary pointer
-    for (unsigned int i = 0; i < pcScene->mNumMeshes;++i)
-        pcScene->mMeshes[i]->mColors[2] = NULL;
+    // Reset the third color set to nullptr - we used this field to store a temporary pointer
+    for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i)
+        pcScene->mMeshes[i]->mColors[2] = nullptr;
 
     // The root node should not have at least one child or the file is valid
     if (!pcScene->mRootNode->mNumChildren) {
@@ -733,17 +723,17 @@ void ASEImporter::BuildNodes(std::vector<BaseNode*>& nodes) {
     }
 
     // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
-    pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f,
-        0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f);
+    pcScene->mRootNode->mTransformation = aiMatrix4x4(1.f, 0.f, 0.f, 0.f,
+            0.f, 0.f, 1.f, 0.f, 0.f, -1.f, 0.f, 0.f, 0.f, 0.f, 0.f, 1.f);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert the imported data to the internal verbose representation
-void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
+void ASEImporter::BuildUniqueRepresentation(ASE::Mesh &mesh) {
     // allocate output storage
     std::vector<aiVector3D> mPositions;
     std::vector<aiVector3D> amTexCoords[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    std::vector<aiColor4D>  mVertexColors;
+    std::vector<aiColor4D> mVertexColors;
     std::vector<aiVector3D> mNormals;
     std::vector<BoneVertex> mBoneVertices;
 
@@ -751,13 +741,13 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
     mPositions.resize(iSize);
 
     // optional texture coordinates
-    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i)    {
-        if (!mesh.amTexCoords[i].empty())   {
+    for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+        if (!mesh.amTexCoords[i].empty()) {
             amTexCoords[i].resize(iSize);
         }
     }
     // optional vertex colors
-    if (!mesh.mVertexColors.empty())    {
+    if (!mesh.mVertexColors.empty()) {
         mVertexColors.resize(iSize);
     }
 
@@ -766,38 +756,37 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
         mNormals.resize(iSize);
     }
     // bone vertices. There is no need to change the bone list
-    if (!mesh.mBoneVertices.empty())    {
+    if (!mesh.mBoneVertices.empty()) {
         mBoneVertices.resize(iSize);
     }
 
     // iterate through all faces in the mesh
     unsigned int iCurrent = 0, fi = 0;
-    for (std::vector<ASE::Face>::iterator i =  mesh.mFaces.begin();i != mesh.mFaces.end();++i,++fi) {
-        for (unsigned int n = 0; n < 3;++n,++iCurrent)
-        {
+    for (std::vector<ASE::Face>::iterator i = mesh.mFaces.begin(); i != mesh.mFaces.end(); ++i, ++fi) {
+        for (unsigned int n = 0; n < 3; ++n, ++iCurrent) {
             mPositions[iCurrent] = mesh.mPositions[(*i).mIndices[n]];
 
             // add texture coordinates
-            for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)    {
-                if (mesh.amTexCoords[c].empty())break;
+            for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+                if (mesh.amTexCoords[c].empty()) break;
                 amTexCoords[c][iCurrent] = mesh.amTexCoords[c][(*i).amUVIndices[c][n]];
             }
             // add vertex colors
-            if (!mesh.mVertexColors.empty())    {
+            if (!mesh.mVertexColors.empty()) {
                 mVertexColors[iCurrent] = mesh.mVertexColors[(*i).mColorIndices[n]];
             }
             // add normal vectors
             if (!mesh.mNormals.empty()) {
-                mNormals[iCurrent] = mesh.mNormals[fi*3+n];
+                mNormals[iCurrent] = mesh.mNormals[fi * 3 + n];
                 mNormals[iCurrent].Normalize();
             }
 
             // handle bone vertices
-            if ((*i).mIndices[n] < mesh.mBoneVertices.size())   {
+            if ((*i).mIndices[n] < mesh.mBoneVertices.size()) {
                 // (sometimes this will cause bone verts to be duplicated
                 //  however, I' quite sure Schrompf' JoinVerticesStep
                 //  will fix that again ...)
-                mBoneVertices[iCurrent] =  mesh.mBoneVertices[(*i).mIndices[n]];
+                mBoneVertices[iCurrent] = mesh.mBoneVertices[(*i).mIndices[n]];
             }
             (*i).mIndices[n] = iCurrent;
         }
@@ -808,31 +797,29 @@ void ASEImporter::BuildUniqueRepresentation(ASE::Mesh& mesh)    {
     mesh.mPositions = mPositions;
     mesh.mVertexColors = mVertexColors;
 
-    for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)
+    for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c)
         mesh.amTexCoords[c] = amTexCoords[c];
 }
 
 // ------------------------------------------------------------------------------------------------
 // Copy a texture from the ASE structs to the output material
-void CopyASETexture(aiMaterial& mat, ASE::Texture& texture, aiTextureType type)
-{
+void CopyASETexture(aiMaterial &mat, ASE::Texture &texture, aiTextureType type) {
     // Setup the texture name
     aiString tex;
-    tex.Set( texture.mMapName);
-    mat.AddProperty( &tex, AI_MATKEY_TEXTURE(type,0));
+    tex.Set(texture.mMapName);
+    mat.AddProperty(&tex, AI_MATKEY_TEXTURE(type, 0));
 
     // Setup the texture blend factor
     if (is_not_qnan(texture.mTextureBlend))
-        mat.AddProperty<ai_real>( &texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type,0));
+        mat.AddProperty<ai_real>(&texture.mTextureBlend, 1, AI_MATKEY_TEXBLEND(type, 0));
 
     // Setup texture UV transformations
-    mat.AddProperty<ai_real>(&texture.mOffsetU,5,AI_MATKEY_UVTRANSFORM(type,0));
+    mat.AddProperty<ai_real>(&texture.mOffsetU, 5, AI_MATKEY_UVTRANSFORM(type, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Convert from ASE material to output material
-void ASEImporter::ConvertMaterial(ASE::Material& mat)
-{
+void ASEImporter::ConvertMaterial(ASE::Material &mat) {
     // LARGE TODO: Much code her is copied from 3DS ... join them maybe?
 
     // Allocate the output material
@@ -845,135 +832,134 @@ void ASEImporter::ConvertMaterial(ASE::Material& mat)
     mat.mAmbient.b += mParser->m_clrAmbient.b;
 
     aiString name;
-    name.Set( mat.mName);
-    mat.pcInstance->AddProperty( &name, AI_MATKEY_NAME);
+    name.Set(mat.mName);
+    mat.pcInstance->AddProperty(&name, AI_MATKEY_NAME);
 
     // material colors
-    mat.pcInstance->AddProperty( &mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
-    mat.pcInstance->AddProperty( &mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-    mat.pcInstance->AddProperty( &mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
-    mat.pcInstance->AddProperty( &mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
+    mat.pcInstance->AddProperty(&mat.mAmbient, 1, AI_MATKEY_COLOR_AMBIENT);
+    mat.pcInstance->AddProperty(&mat.mDiffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    mat.pcInstance->AddProperty(&mat.mSpecular, 1, AI_MATKEY_COLOR_SPECULAR);
+    mat.pcInstance->AddProperty(&mat.mEmissive, 1, AI_MATKEY_COLOR_EMISSIVE);
 
     // shininess
-    if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength)
-    {
-        mat.pcInstance->AddProperty( &mat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
-        mat.pcInstance->AddProperty( &mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
+    if (0.0f != mat.mSpecularExponent && 0.0f != mat.mShininessStrength) {
+        mat.pcInstance->AddProperty(&mat.mSpecularExponent, 1, AI_MATKEY_SHININESS);
+        mat.pcInstance->AddProperty(&mat.mShininessStrength, 1, AI_MATKEY_SHININESS_STRENGTH);
     }
     // If there is no shininess, we can disable phong lighting
     else if (D3DS::Discreet3DS::Metal == mat.mShading ||
-        D3DS::Discreet3DS::Phong == mat.mShading ||
-        D3DS::Discreet3DS::Blinn == mat.mShading)
-    {
+             D3DS::Discreet3DS::Phong == mat.mShading ||
+             D3DS::Discreet3DS::Blinn == mat.mShading) {
         mat.mShading = D3DS::Discreet3DS::Gouraud;
     }
 
     // opacity
-    mat.pcInstance->AddProperty<ai_real>( &mat.mTransparency,1,AI_MATKEY_OPACITY);
+    mat.pcInstance->AddProperty<ai_real>(&mat.mTransparency, 1, AI_MATKEY_OPACITY);
 
     // Two sided rendering?
-    if (mat.mTwoSided)
-    {
+    if (mat.mTwoSided) {
         int i = 1;
-        mat.pcInstance->AddProperty<int>(&i,1,AI_MATKEY_TWOSIDED);
+        mat.pcInstance->AddProperty<int>(&i, 1, AI_MATKEY_TWOSIDED);
     }
 
     // shading mode
     aiShadingMode eShading = aiShadingMode_NoShading;
-    switch (mat.mShading)
-    {
-        case D3DS::Discreet3DS::Flat:
-            eShading = aiShadingMode_Flat; break;
-        case D3DS::Discreet3DS::Phong :
-            eShading = aiShadingMode_Phong; break;
-        case D3DS::Discreet3DS::Blinn :
-            eShading = aiShadingMode_Blinn; break;
+    switch (mat.mShading) {
+    case D3DS::Discreet3DS::Flat:
+        eShading = aiShadingMode_Flat;
+        break;
+    case D3DS::Discreet3DS::Phong:
+        eShading = aiShadingMode_Phong;
+        break;
+    case D3DS::Discreet3DS::Blinn:
+        eShading = aiShadingMode_Blinn;
+        break;
 
-            // I don't know what "Wire" shading should be,
-            // assume it is simple lambertian diffuse (L dot N) shading
-        case D3DS::Discreet3DS::Wire:
-            {
-                // set the wireframe flag
-                unsigned int iWire = 1;
-                mat.pcInstance->AddProperty<int>( (int*)&iWire,1,AI_MATKEY_ENABLE_WIREFRAME);
-            }
-        case D3DS::Discreet3DS::Gouraud:
-            eShading = aiShadingMode_Gouraud; break;
-        case D3DS::Discreet3DS::Metal :
-            eShading = aiShadingMode_CookTorrance; break;
+        // I don't know what "Wire" shading should be,
+        // assume it is simple lambertian diffuse (L dot N) shading
+    case D3DS::Discreet3DS::Wire: {
+        // set the wireframe flag
+        unsigned int iWire = 1;
+        mat.pcInstance->AddProperty<int>((int *)&iWire, 1, AI_MATKEY_ENABLE_WIREFRAME);
     }
-    mat.pcInstance->AddProperty<int>( (int*)&eShading,1,AI_MATKEY_SHADING_MODEL);
+    case D3DS::Discreet3DS::Gouraud:
+        eShading = aiShadingMode_Gouraud;
+        break;
+    case D3DS::Discreet3DS::Metal:
+        eShading = aiShadingMode_CookTorrance;
+        break;
+    }
+    mat.pcInstance->AddProperty<int>((int *)&eShading, 1, AI_MATKEY_SHADING_MODEL);
 
     // DIFFUSE texture
-    if( mat.sTexDiffuse.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexDiffuse, aiTextureType_DIFFUSE);
+    if (mat.sTexDiffuse.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexDiffuse, aiTextureType_DIFFUSE);
 
     // SPECULAR texture
-    if( mat.sTexSpecular.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexSpecular, aiTextureType_SPECULAR);
+    if (mat.sTexSpecular.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexSpecular, aiTextureType_SPECULAR);
 
     // AMBIENT texture
-    if( mat.sTexAmbient.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexAmbient, aiTextureType_AMBIENT);
+    if (mat.sTexAmbient.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexAmbient, aiTextureType_AMBIENT);
 
     // OPACITY texture
-    if( mat.sTexOpacity.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexOpacity, aiTextureType_OPACITY);
+    if (mat.sTexOpacity.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexOpacity, aiTextureType_OPACITY);
 
     // EMISSIVE texture
-    if( mat.sTexEmissive.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexEmissive, aiTextureType_EMISSIVE);
+    if (mat.sTexEmissive.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexEmissive, aiTextureType_EMISSIVE);
 
     // BUMP texture
-    if( mat.sTexBump.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexBump, aiTextureType_HEIGHT);
+    if (mat.sTexBump.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexBump, aiTextureType_HEIGHT);
 
     // SHININESS texture
-    if( mat.sTexShininess.mMapName.length() > 0)
-        CopyASETexture(*mat.pcInstance,mat.sTexShininess, aiTextureType_SHININESS);
+    if (mat.sTexShininess.mMapName.length() > 0)
+        CopyASETexture(*mat.pcInstance, mat.sTexShininess, aiTextureType_SHININESS);
 
     // store the name of the material itself, too
-    if( mat.mName.length() > 0) {
-        aiString tex;tex.Set( mat.mName);
-        mat.pcInstance->AddProperty( &tex, AI_MATKEY_NAME);
+    if (mat.mName.length() > 0) {
+        aiString tex;
+        tex.Set(mat.mName);
+        mat.pcInstance->AddProperty(&tex, AI_MATKEY_NAME);
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build output meshes
-void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMeshes)
-{
+void ASEImporter::ConvertMeshes(ASE::Mesh &mesh, std::vector<aiMesh *> &avOutMeshes) {
     // validate the material index of the mesh
-    if (mesh.iMaterialIndex >= mParser->m_vMaterials.size())    {
-        mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size()-1;
+    if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) {
+        mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size() - 1;
         ASSIMP_LOG_WARN("Material index is out of range");
     }
 
     // If the material the mesh is assigned to is consisting of submeshes, split it
     if (!mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials.empty()) {
-        std::vector<ASE::Material> vSubMaterials = mParser->
-            m_vMaterials[mesh.iMaterialIndex].avSubMaterials;
+        std::vector<ASE::Material> vSubMaterials = mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials;
 
-        std::vector<unsigned int>* aiSplit = new std::vector<unsigned int>[vSubMaterials.size()];
+        std::vector<unsigned int> *aiSplit = new std::vector<unsigned int>[vSubMaterials.size()];
 
         // build a list of all faces per sub-material
-        for (unsigned int i = 0; i < mesh.mFaces.size();++i)    {
+        for (unsigned int i = 0; i < mesh.mFaces.size(); ++i) {
             // check range
             if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) {
                 ASSIMP_LOG_WARN("Submaterial index is out of range");
 
                 // use the last material instead
-                aiSplit[vSubMaterials.size()-1].push_back(i);
-            }
-            else aiSplit[mesh.mFaces[i].iMaterial].push_back(i);
+                aiSplit[vSubMaterials.size() - 1].push_back(i);
+            } else
+                aiSplit[mesh.mFaces[i].iMaterial].push_back(i);
         }
 
         // now generate submeshes
-        for (unsigned int p = 0; p < vSubMaterials.size();++p)  {
-            if (!aiSplit[p].empty())    {
+        for (unsigned int p = 0; p < vSubMaterials.size(); ++p) {
+            if (!aiSplit[p].empty()) {
 
-                aiMesh* p_pcOut = new aiMesh();
+                aiMesh *p_pcOut = new aiMesh();
                 p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
                 // let the sub material index
@@ -983,55 +969,55 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
                 mParser->m_vMaterials[mesh.iMaterialIndex].avSubMaterials[p].bNeed = true;
 
                 // store the real index here ... color channel 3
-                p_pcOut->mColors[3] = (aiColor4D*)(uintptr_t)mesh.iMaterialIndex;
+                p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;
 
                 // store a pointer to the mesh in color channel 2
-                p_pcOut->mColors[2] = (aiColor4D*) &mesh;
+                p_pcOut->mColors[2] = (aiColor4D *)&mesh;
                 avOutMeshes.push_back(p_pcOut);
 
                 // convert vertices
-                p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size()*3;
+                p_pcOut->mNumVertices = (unsigned int)aiSplit[p].size() * 3;
                 p_pcOut->mNumFaces = (unsigned int)aiSplit[p].size();
 
                 // receive output vertex weights
-                std::vector<std::pair<unsigned int, float> > *avOutputBones = NULL;
-                if (!mesh.mBones.empty())   {
-                    avOutputBones = new std::vector<std::pair<unsigned int, float> >[mesh.mBones.size()];
+                std::vector<std::pair<unsigned int, float>> *avOutputBones = nullptr;
+                if (!mesh.mBones.empty()) {
+                    avOutputBones = new std::vector<std::pair<unsigned int, float>>[mesh.mBones.size()];
                 }
 
                 // allocate enough storage for faces
                 p_pcOut->mFaces = new aiFace[p_pcOut->mNumFaces];
 
-                unsigned int iBase = 0,iIndex;
-                if (p_pcOut->mNumVertices)  {
+                unsigned int iBase = 0, iIndex;
+                if (p_pcOut->mNumVertices) {
                     p_pcOut->mVertices = new aiVector3D[p_pcOut->mNumVertices];
-                    p_pcOut->mNormals  = new aiVector3D[p_pcOut->mNumVertices];
-                    for (unsigned int q = 0; q < aiSplit[p].size();++q) {
+                    p_pcOut->mNormals = new aiVector3D[p_pcOut->mNumVertices];
+                    for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
 
                         iIndex = aiSplit[p][q];
 
                         p_pcOut->mFaces[q].mIndices = new unsigned int[3];
                         p_pcOut->mFaces[q].mNumIndices = 3;
 
-                        for (unsigned int t = 0; t < 3;++t, ++iBase)    {
+                        for (unsigned int t = 0; t < 3; ++t, ++iBase) {
                             const uint32_t iIndex2 = mesh.mFaces[iIndex].mIndices[t];
 
-                            p_pcOut->mVertices[iBase] = mesh.mPositions [iIndex2];
-                            p_pcOut->mNormals [iBase] = mesh.mNormals   [iIndex2];
+                            p_pcOut->mVertices[iBase] = mesh.mPositions[iIndex2];
+                            p_pcOut->mNormals[iBase] = mesh.mNormals[iIndex2];
 
                             // convert bones, if existing
                             if (!mesh.mBones.empty()) {
                                 ai_assert(avOutputBones);
                                 // check whether there is a vertex weight for this vertex index
-                                if (iIndex2 < mesh.mBoneVertices.size())    {
+                                if (iIndex2 < mesh.mBoneVertices.size()) {
 
-                                    for (std::vector<std::pair<int,float> >::const_iterator
-                                        blubb =  mesh.mBoneVertices[iIndex2].mBoneWeights.begin();
-                                        blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end();++blubb)    {
+                                    for (std::vector<std::pair<int, float>>::const_iterator
+                                                    blubb = mesh.mBoneVertices[iIndex2].mBoneWeights.begin();
+                                            blubb != mesh.mBoneVertices[iIndex2].mBoneWeights.end(); ++blubb) {
 
                                         // NOTE: illegal cases have already been filtered out
                                         avOutputBones[(*blubb).first].push_back(std::pair<unsigned int, float>(
-                                            iBase,(*blubb).second));
+                                                iBase, (*blubb).second));
                                     }
                                 }
                             }
@@ -1040,14 +1026,13 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
                     }
                 }
                 // convert texture coordinates (up to AI_MAX_NUMBER_OF_TEXTURECOORDS sets supported)
-                for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c) {
-                    if (!mesh.amTexCoords[c].empty())
-                    {
+                for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+                    if (!mesh.amTexCoords[c].empty()) {
                         p_pcOut->mTextureCoords[c] = new aiVector3D[p_pcOut->mNumVertices];
                         iBase = 0;
-                        for (unsigned int q = 0; q < aiSplit[p].size();++q) {
+                        for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
                             iIndex = aiSplit[p][q];
-                            for (unsigned int t = 0; t < 3;++t) {
+                            for (unsigned int t = 0; t < 3; ++t) {
                                 p_pcOut->mTextureCoords[c][iBase++] = mesh.amTexCoords[c][mesh.mFaces[iIndex].mIndices[t]];
                             }
                         }
@@ -1057,38 +1042,36 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
                 }
 
                 // Convert vertex colors (only one set supported)
-                if (!mesh.mVertexColors.empty()){
+                if (!mesh.mVertexColors.empty()) {
                     p_pcOut->mColors[0] = new aiColor4D[p_pcOut->mNumVertices];
                     iBase = 0;
-                    for (unsigned int q = 0; q < aiSplit[p].size();++q) {
+                    for (unsigned int q = 0; q < aiSplit[p].size(); ++q) {
                         iIndex = aiSplit[p][q];
-                        for (unsigned int t = 0; t < 3;++t) {
+                        for (unsigned int t = 0; t < 3; ++t) {
                             p_pcOut->mColors[0][iBase++] = mesh.mVertexColors[mesh.mFaces[iIndex].mIndices[t]];
                         }
                     }
                 }
                 // Copy bones
-                if (!mesh.mBones.empty())   {
+                if (!mesh.mBones.empty()) {
                     p_pcOut->mNumBones = 0;
-                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size();++mrspock)
-                        if (!avOutputBones[mrspock].empty())p_pcOut->mNumBones++;
+                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock)
+                        if (!avOutputBones[mrspock].empty()) p_pcOut->mNumBones++;
 
-                    p_pcOut->mBones = new aiBone* [ p_pcOut->mNumBones ];
-                    aiBone** pcBone = p_pcOut->mBones;
-                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size();++mrspock)
-                    {
-                        if (!avOutputBones[mrspock].empty())    {
+                    p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones];
+                    aiBone **pcBone = p_pcOut->mBones;
+                    for (unsigned int mrspock = 0; mrspock < mesh.mBones.size(); ++mrspock) {
+                        if (!avOutputBones[mrspock].empty()) {
                             // we will need this bone. add it to the output mesh and
                             // add all per-vertex weights
-                            aiBone* pc = *pcBone = new aiBone();
+                            aiBone *pc = *pcBone = new aiBone();
                             pc->mName.Set(mesh.mBones[mrspock].mName);
 
                             pc->mNumWeights = (unsigned int)avOutputBones[mrspock].size();
                             pc->mWeights = new aiVertexWeight[pc->mNumWeights];
 
-                            for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights;++captainkirk)
-                            {
-                                const std::pair<unsigned int,float>& ref = avOutputBones[mrspock][captainkirk];
+                            for (unsigned int captainkirk = 0; captainkirk < pc->mNumWeights; ++captainkirk) {
+                                const std::pair<unsigned int, float> &ref = avOutputBones[mrspock][captainkirk];
                                 pc->mWeights[captainkirk].mVertexId = ref.first;
                                 pc->mWeights[captainkirk].mWeight = ref.second;
                             }
@@ -1102,15 +1085,13 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         }
         // delete storage
         delete[] aiSplit;
-    }
-    else
-    {
+    } else {
         // Otherwise we can simply copy the data to one output mesh
         // This codepath needs less memory and uses fast memcpy()s
         // to do the actual copying. So I think it is worth the
         // effort here.
 
-        aiMesh* p_pcOut = new aiMesh();
+        aiMesh *p_pcOut = new aiMesh();
         p_pcOut->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
 
         // set an empty sub material index
@@ -1118,10 +1099,10 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         mParser->m_vMaterials[mesh.iMaterialIndex].bNeed = true;
 
         // store the real index here ... in color channel 3
-        p_pcOut->mColors[3] = (aiColor4D*)(uintptr_t)mesh.iMaterialIndex;
+        p_pcOut->mColors[3] = (aiColor4D *)(uintptr_t)mesh.iMaterialIndex;
 
         // store a pointer to the mesh in color channel 2
-        p_pcOut->mColors[2] = (aiColor4D*) &mesh;
+        p_pcOut->mColors[2] = (aiColor4D *)&mesh;
         avOutMeshes.push_back(p_pcOut);
 
         // If the mesh hasn't faces or vertices, there are two cases
@@ -1140,20 +1121,20 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
 
         // copy vertices
         p_pcOut->mVertices = new aiVector3D[mesh.mPositions.size()];
-        memcpy(p_pcOut->mVertices,&mesh.mPositions[0],
-            mesh.mPositions.size() * sizeof(aiVector3D));
+        memcpy(p_pcOut->mVertices, &mesh.mPositions[0],
+                mesh.mPositions.size() * sizeof(aiVector3D));
 
         // copy normals
         p_pcOut->mNormals = new aiVector3D[mesh.mNormals.size()];
-        memcpy(p_pcOut->mNormals,&mesh.mNormals[0],
-            mesh.mNormals.size() * sizeof(aiVector3D));
+        memcpy(p_pcOut->mNormals, &mesh.mNormals[0],
+                mesh.mNormals.size() * sizeof(aiVector3D));
 
         // copy texture coordinates
-        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS;++c)    {
-            if (!mesh.amTexCoords[c].empty())   {
+        for (unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c) {
+            if (!mesh.amTexCoords[c].empty()) {
                 p_pcOut->mTextureCoords[c] = new aiVector3D[mesh.amTexCoords[c].size()];
-                memcpy(p_pcOut->mTextureCoords[c],&mesh.amTexCoords[c][0],
-                    mesh.amTexCoords[c].size() * sizeof(aiVector3D));
+                memcpy(p_pcOut->mTextureCoords[c], &mesh.amTexCoords[c][0],
+                        mesh.amTexCoords[c].size() * sizeof(aiVector3D));
 
                 // setup the number of valid vertex components
                 p_pcOut->mNumUVComponents[c] = mesh.mNumUVComponents[c];
@@ -1161,14 +1142,14 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         }
 
         // copy vertex colors
-        if (!mesh.mVertexColors.empty())    {
+        if (!mesh.mVertexColors.empty()) {
             p_pcOut->mColors[0] = new aiColor4D[mesh.mVertexColors.size()];
-            memcpy(p_pcOut->mColors[0],&mesh.mVertexColors[0],
-                mesh.mVertexColors.size() * sizeof(aiColor4D));
+            memcpy(p_pcOut->mColors[0], &mesh.mVertexColors[0],
+                    mesh.mVertexColors.size() * sizeof(aiColor4D));
         }
 
         // copy faces
-        for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces;++iFace)    {
+        for (unsigned int iFace = 0; iFace < p_pcOut->mNumFaces; ++iFace) {
             p_pcOut->mFaces[iFace].mNumIndices = 3;
             p_pcOut->mFaces[iFace].mIndices = new unsigned int[3];
 
@@ -1179,18 +1160,17 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
         }
 
         // copy vertex bones
-        if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty())    {
-            std::vector<std::vector<aiVertexWeight> > avBonesOut( mesh.mBones.size() );
+        if (!mesh.mBones.empty() && !mesh.mBoneVertices.empty()) {
+            std::vector<std::vector<aiVertexWeight>> avBonesOut(mesh.mBones.size());
 
             // find all vertex weights for this bone
             unsigned int quak = 0;
-            for (std::vector<BoneVertex>::const_iterator harrypotter =  mesh.mBoneVertices.begin();
-                harrypotter != mesh.mBoneVertices.end();++harrypotter,++quak)   {
+            for (std::vector<BoneVertex>::const_iterator harrypotter = mesh.mBoneVertices.begin();
+                    harrypotter != mesh.mBoneVertices.end(); ++harrypotter, ++quak) {
 
-                for (std::vector<std::pair<int,float> >::const_iterator
-                    ronaldweasley  = (*harrypotter).mBoneWeights.begin();
-                    ronaldweasley != (*harrypotter).mBoneWeights.end();++ronaldweasley)
-                {
+                for (std::vector<std::pair<int, float>>::const_iterator
+                                ronaldweasley = (*harrypotter).mBoneWeights.begin();
+                        ronaldweasley != (*harrypotter).mBoneWeights.end(); ++ronaldweasley) {
                     aiVertexWeight weight;
                     weight.mVertexId = quak;
                     weight.mWeight = (*ronaldweasley).second;
@@ -1200,19 +1180,19 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
 
             // now build a final bone list
             p_pcOut->mNumBones = 0;
-            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size();++jfkennedy)
-                if (!avBonesOut[jfkennedy].empty())p_pcOut->mNumBones++;
+            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy)
+                if (!avBonesOut[jfkennedy].empty()) p_pcOut->mNumBones++;
 
-            p_pcOut->mBones = new aiBone*[p_pcOut->mNumBones];
-            aiBone** pcBone = p_pcOut->mBones;
-            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size();++jfkennedy)    {
+            p_pcOut->mBones = new aiBone *[p_pcOut->mNumBones];
+            aiBone **pcBone = p_pcOut->mBones;
+            for (unsigned int jfkennedy = 0; jfkennedy < mesh.mBones.size(); ++jfkennedy) {
                 if (!avBonesOut[jfkennedy].empty()) {
-                    aiBone* pc = *pcBone = new aiBone();
+                    aiBone *pc = *pcBone = new aiBone();
                     pc->mName.Set(mesh.mBones[jfkennedy].mName);
                     pc->mNumWeights = (unsigned int)avBonesOut[jfkennedy].size();
                     pc->mWeights = new aiVertexWeight[pc->mNumWeights];
-                    ::memcpy(pc->mWeights,&avBonesOut[jfkennedy][0],
-                        sizeof(aiVertexWeight) * pc->mNumWeights);
+                    ::memcpy(pc->mWeights, &avBonesOut[jfkennedy][0],
+                            sizeof(aiVertexWeight) * pc->mNumWeights);
                     ++pcBone;
                 }
             }
@@ -1222,23 +1202,20 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
 
 // ------------------------------------------------------------------------------------------------
 // Setup proper material indices and build output materials
-void ASEImporter::BuildMaterialIndices()
-{
-    ai_assert(NULL != pcScene);
+void ASEImporter::BuildMaterialIndices() {
+    ai_assert(nullptr != pcScene);
 
     // iterate through all materials and check whether we need them
-    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size();++iMat)
-    {
-        ASE::Material& mat = mParser->m_vMaterials[iMat];
-        if (mat.bNeed)  {
+    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) {
+        ASE::Material &mat = mParser->m_vMaterials[iMat];
+        if (mat.bNeed) {
             // Convert it to the aiMaterial layout
             ConvertMaterial(mat);
             ++pcScene->mNumMaterials;
         }
-        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size();++iSubMat)
-        {
-            ASE::Material& submat = mat.avSubMaterials[iSubMat];
-            if (submat.bNeed)   {
+        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) {
+            ASE::Material &submat = mat.avSubMaterials[iSubMat];
+            if (submat.bNeed) {
                 // Convert it to the aiMaterial layout
                 ConvertMaterial(submat);
                 ++pcScene->mNumMaterials;
@@ -1247,15 +1224,14 @@ void ASEImporter::BuildMaterialIndices()
     }
 
     // allocate the output material array
-    pcScene->mMaterials = new aiMaterial*[pcScene->mNumMaterials];
-    D3DS::Material** pcIntMaterials = new D3DS::Material*[pcScene->mNumMaterials];
+    pcScene->mMaterials = new aiMaterial *[pcScene->mNumMaterials];
+    D3DS::Material **pcIntMaterials = new D3DS::Material *[pcScene->mNumMaterials];
 
     unsigned int iNum = 0;
-    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size();++iMat) {
-        ASE::Material& mat = mParser->m_vMaterials[iMat];
-        if (mat.bNeed)
-        {
-            ai_assert(NULL != mat.pcInstance);
+    for (unsigned int iMat = 0; iMat < mParser->m_vMaterials.size(); ++iMat) {
+        ASE::Material &mat = mParser->m_vMaterials[iMat];
+        if (mat.bNeed) {
+            ai_assert(nullptr != mat.pcInstance);
             pcScene->mMaterials[iNum] = mat.pcInstance;
 
             // Store the internal material, too
@@ -1263,22 +1239,20 @@ void ASEImporter::BuildMaterialIndices()
 
             // Iterate through all meshes and search for one which is using
             // this top-level material index
-            for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes;++iMesh)
-            {
-                aiMesh* mesh = pcScene->mMeshes[iMesh];
+            for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) {
+                aiMesh *mesh = pcScene->mMeshes[iMesh];
                 if (ASE::Face::DEFAULT_MATINDEX == mesh->mMaterialIndex &&
-                    iMat == (uintptr_t)mesh->mColors[3])
-                {
+                        iMat == (uintptr_t)mesh->mColors[3]) {
                     mesh->mMaterialIndex = iNum;
-                    mesh->mColors[3] = NULL;
+                    mesh->mColors[3] = nullptr;
                 }
             }
             iNum++;
         }
-        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size();++iSubMat)   {
-            ASE::Material& submat = mat.avSubMaterials[iSubMat];
-            if (submat.bNeed)   {
-                ai_assert(NULL != submat.pcInstance);
+        for (unsigned int iSubMat = 0; iSubMat < mat.avSubMaterials.size(); ++iSubMat) {
+            ASE::Material &submat = mat.avSubMaterials[iSubMat];
+            if (submat.bNeed) {
+                ai_assert(nullptr != submat.pcInstance);
                 pcScene->mMaterials[iNum] = submat.pcInstance;
 
                 // Store the internal material, too
@@ -1286,12 +1260,12 @@ void ASEImporter::BuildMaterialIndices()
 
                 // Iterate through all meshes and search for one which is using
                 // this sub-level material index
-                for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes;++iMesh)   {
-                    aiMesh* mesh = pcScene->mMeshes[iMesh];
+                for (unsigned int iMesh = 0; iMesh < pcScene->mNumMeshes; ++iMesh) {
+                    aiMesh *mesh = pcScene->mMeshes[iMesh];
 
                     if (iSubMat == mesh->mMaterialIndex && iMat == (uintptr_t)mesh->mColors[3]) {
                         mesh->mMaterialIndex = iNum;
-                        mesh->mColors[3]     = NULL;
+                        mesh->mColors[3] = nullptr;
                     }
                 }
                 iNum++;
@@ -1305,15 +1279,13 @@ void ASEImporter::BuildMaterialIndices()
 
 // ------------------------------------------------------------------------------------------------
 // Generate normal vectors basing on smoothing groups
-bool ASEImporter::GenerateNormals(ASE::Mesh& mesh)  {
+bool ASEImporter::GenerateNormals(ASE::Mesh &mesh) {
 
-    if (!mesh.mNormals.empty() && !configRecomputeNormals)
-    {
+    if (!mesh.mNormals.empty() && !configRecomputeNormals) {
         // Check whether there are only uninitialized normals. If there are
         // some, skip all normals from the file and compute them on our own
-        for (std::vector<aiVector3D>::const_iterator qq =  mesh.mNormals.begin();qq != mesh.mNormals.end();++qq) {
-            if ((*qq).x || (*qq).y || (*qq).z)
-            {
+        for (std::vector<aiVector3D>::const_iterator qq = mesh.mNormals.begin(); qq != mesh.mNormals.end(); ++qq) {
+            if ((*qq).x || (*qq).y || (*qq).z) {
                 return true;
             }
         }
diff --git a/code/ASE/ASELoader.h b/code/AssetLib/ASE/ASELoader.h
similarity index 100%
rename from code/ASE/ASELoader.h
rename to code/AssetLib/ASE/ASELoader.h
diff --git a/code/ASE/ASEParser.cpp b/code/AssetLib/ASE/ASEParser.cpp
similarity index 59%
rename from code/ASE/ASEParser.cpp
rename to code/AssetLib/ASE/ASEParser.cpp
index 72e8b3373..09ad2ab1d 100644
--- a/code/ASE/ASEParser.cpp
+++ b/code/AssetLib/ASE/ASEParser.cpp
@@ -49,8 +49,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers
-#include "PostProcessing/TextureTransform.h"
 #include "ASELoader.h"
+#include "PostProcessing/TextureTransform.h"
 
 #include <assimp/fast_atof.h>
 #include <assimp/DefaultLogger.hpp>
@@ -67,26 +67,23 @@ using namespace Assimp::ASE;
 // ------------------------------------------------------------------------------------------------
 // Handle a "top-level" section in the file. EOF is no error in this case.
 
-#define AI_ASE_HANDLE_TOP_LEVEL_SECTION() \
-    else if ('{' == *filePtr)iDepth++; \
-    else if ('}' == *filePtr) \
-    { \
-        if (0 == --iDepth) \
-        { \
-            ++filePtr; \
-            SkipToNextToken(); \
-            return; \
-        } \
-    } \
-    else if ('\0' == *filePtr) \
-    { \
-        return; \
-    } \
-    if(IsLineEnd(*filePtr) && !bLastWasEndLine) \
-    { \
-        ++iLineNumber; \
-        bLastWasEndLine = true; \
-    } else bLastWasEndLine = false; \
+#define AI_ASE_HANDLE_TOP_LEVEL_SECTION()          \
+    else if ('{' == *filePtr) iDepth++;            \
+    else if ('}' == *filePtr) {                    \
+        if (0 == --iDepth) {                       \
+            ++filePtr;                             \
+            SkipToNextToken();                     \
+            return;                                \
+        }                                          \
+    }                                              \
+    else if ('\0' == *filePtr) {                   \
+        return;                                    \
+    }                                              \
+    if (IsLineEnd(*filePtr) && !bLastWasEndLine) { \
+        ++iLineNumber;                             \
+        bLastWasEndLine = true;                    \
+    } else                                         \
+        bLastWasEndLine = false;                   \
     ++filePtr;
 
 // ------------------------------------------------------------------------------------------------
@@ -94,59 +91,54 @@ using namespace Assimp::ASE;
 // @param level "Depth" of the section
 // @param msg Full name of the section (including the asterisk)
 
-#define AI_ASE_HANDLE_SECTION(level, msg) \
-    if ('{' == *filePtr)iDepth++; \
-    else if ('}' == *filePtr) \
-    { \
-        if (0 == --iDepth) \
-        { \
-            ++filePtr; \
-            SkipToNextToken(); \
-            return; \
-        } \
-    } \
-    else if ('\0' == *filePtr) \
-    { \
+#define AI_ASE_HANDLE_SECTION(level, msg)                          \
+    if ('{' == *filePtr)                                           \
+        iDepth++;                                                  \
+    else if ('}' == *filePtr) {                                    \
+        if (0 == --iDepth) {                                       \
+            ++filePtr;                                             \
+            SkipToNextToken();                                     \
+            return;                                                \
+        }                                                          \
+    } else if ('\0' == *filePtr) {                                 \
         LogError("Encountered unexpected EOL while parsing a " msg \
-        " chunk (Level " level ")"); \
-    } \
-    if(IsLineEnd(*filePtr) && !bLastWasEndLine) \
-        { \
-        ++iLineNumber; \
-        bLastWasEndLine = true; \
-    } else bLastWasEndLine = false; \
+                 " chunk (Level " level ")");                      \
+    }                                                              \
+    if (IsLineEnd(*filePtr) && !bLastWasEndLine) {                 \
+        ++iLineNumber;                                             \
+        bLastWasEndLine = true;                                    \
+    } else                                                         \
+        bLastWasEndLine = false;                                   \
     ++filePtr;
 
 // ------------------------------------------------------------------------------------------------
-Parser::Parser (const char* szFile, unsigned int fileFormatDefault)
-{
-    ai_assert(NULL != szFile);
+Parser::Parser(const char *szFile, unsigned int fileFormatDefault) {
+    ai_assert(nullptr != szFile);
     filePtr = szFile;
     iFileFormat = fileFormatDefault;
 
     // make sure that the color values are invalid
     m_clrBackground.r = get_qnan();
-    m_clrAmbient.r    = get_qnan();
+    m_clrAmbient.r = get_qnan();
 
     // setup some default values
     iLineNumber = 0;
     iFirstFrame = 0;
     iLastFrame = 0;
-    iFrameSpeed = 30;        // use 30 as default value for this property
-    iTicksPerFrame = 1;      // use 1 as default value for this property
+    iFrameSpeed = 30; // use 30 as default value for this property
+    iTicksPerFrame = 1; // use 1 as default value for this property
     bLastWasEndLine = false; // need to handle \r\n seqs due to binary file mapping
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::LogWarning(const char* szWarn)
-{
-    ai_assert(NULL != szWarn);
+void Parser::LogWarning(const char *szWarn) {
+    ai_assert(nullptr != szWarn);
 
     char szTemp[2048];
 #if _MSC_VER >= 1400
-    sprintf_s(szTemp, "Line %u: %s",iLineNumber,szWarn);
+    sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn);
 #else
-    ai_snprintf(szTemp,sizeof(szTemp),"Line %u: %s",iLineNumber,szWarn);
+    ai_snprintf(szTemp, sizeof(szTemp), "Line %u: %s", iLineNumber, szWarn);
 #endif
 
     // output the warning to the logger ...
@@ -154,15 +146,14 @@ void Parser::LogWarning(const char* szWarn)
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::LogInfo(const char* szWarn)
-{
-    ai_assert(NULL != szWarn);
+void Parser::LogInfo(const char *szWarn) {
+    ai_assert(nullptr != szWarn);
 
     char szTemp[1024];
 #if _MSC_VER >= 1400
-    sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
+    sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn);
 #else
-    ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
+    ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn);
 #endif
 
     // output the information to the logger ...
@@ -170,15 +161,14 @@ void Parser::LogInfo(const char* szWarn)
 }
 
 // ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void Parser::LogError(const char* szWarn)
-{
-    ai_assert(NULL != szWarn);
+AI_WONT_RETURN void Parser::LogError(const char *szWarn) {
+    ai_assert(nullptr != szWarn);
 
     char szTemp[1024];
 #if _MSC_VER >= 1400
-    sprintf_s(szTemp,"Line %u: %s",iLineNumber,szWarn);
+    sprintf_s(szTemp, "Line %u: %s", iLineNumber, szWarn);
 #else
-    ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,szWarn);
+    ai_snprintf(szTemp, 1024, "Line %u: %s", iLineNumber, szWarn);
 #endif
 
     // throw an exception
@@ -186,76 +176,60 @@ AI_WONT_RETURN void Parser::LogError(const char* szWarn)
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Parser::SkipToNextToken()
-{
-    while (true)
-    {
+bool Parser::SkipToNextToken() {
+    while (true) {
         char me = *filePtr;
 
         // increase the line number counter if necessary
-        if (IsLineEnd(me) && !bLastWasEndLine)
-        {
+        if (IsLineEnd(me) && !bLastWasEndLine) {
             ++iLineNumber;
             bLastWasEndLine = true;
-        }
-        else bLastWasEndLine = false;
-        if ('*' == me || '}' == me || '{' == me)return true;
-        if ('\0' == me)return false;
+        } else
+            bLastWasEndLine = false;
+        if ('*' == me || '}' == me || '{' == me) return true;
+        if ('\0' == me) return false;
 
         ++filePtr;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Parser::SkipSection()
-{
+bool Parser::SkipSection() {
     // must handle subsections ...
     int iCnt = 0;
-    while (true)
-    {
-        if ('}' == *filePtr)
-        {
+    while (true) {
+        if ('}' == *filePtr) {
             --iCnt;
-            if (0 == iCnt)
-            {
+            if (0 == iCnt) {
                 // go to the next valid token ...
                 ++filePtr;
                 SkipToNextToken();
                 return true;
             }
-        }
-        else if ('{' == *filePtr)
-        {
+        } else if ('{' == *filePtr) {
             ++iCnt;
-        }
-        else if ('\0' == *filePtr)
-        {
+        } else if ('\0' == *filePtr) {
             LogWarning("Unable to parse block: Unexpected EOF, closing bracket \'}\' was expected [#1]");
             return false;
-        }
-        else if(IsLineEnd(*filePtr))++iLineNumber;
+        } else if (IsLineEnd(*filePtr))
+            ++iLineNumber;
         ++filePtr;
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::Parse()
-{
+void Parser::Parse() {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Version should be 200. Validate this ...
-            if (TokenMatch(filePtr,"3DSMAX_ASCIIEXPORT",18))
-            {
+            if (TokenMatch(filePtr, "3DSMAX_ASCIIEXPORT", 18)) {
                 unsigned int fmt;
                 ParseLV4MeshLong(fmt);
 
-                if (fmt > 200)
-                {
+                if (fmt > 200) {
                     LogWarning("Unknown file format version: *3DSMAX_ASCIIEXPORT should \
                                be <= 200");
                 }
@@ -266,32 +240,29 @@ void Parser::Parse()
                 // at the file extension (ASE, ASK, ASC)
                 // *************************************************************
 
-                if ( fmt ) {
+                if (fmt) {
                     iFileFormat = fmt;
                 }
                 continue;
             }
             // main scene information
-            if (TokenMatch(filePtr,"SCENE",5))
-            {
+            if (TokenMatch(filePtr, "SCENE", 5)) {
                 ParseLV1SceneBlock();
                 continue;
             }
             // "group" - no implementation yet, in facte
             // we're just ignoring them for the moment
-            if (TokenMatch(filePtr,"GROUP",5))
-            {
+            if (TokenMatch(filePtr, "GROUP", 5)) {
                 Parse();
                 continue;
             }
             // material list
-            if (TokenMatch(filePtr,"MATERIAL_LIST",13))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_LIST", 13)) {
                 ParseLV1MaterialListBlock();
                 continue;
             }
             // geometric object (mesh)
-            if (TokenMatch(filePtr,"GEOMOBJECT",10))
+            if (TokenMatch(filePtr, "GEOMOBJECT", 10))
 
             {
                 m_vMeshes.push_back(Mesh("UNNAMED"));
@@ -299,7 +270,7 @@ void Parser::Parse()
                 continue;
             }
             // helper object = dummy in the hierarchy
-            if (TokenMatch(filePtr,"HELPEROBJECT",12))
+            if (TokenMatch(filePtr, "HELPEROBJECT", 12))
 
             {
                 m_vDummies.push_back(Dummy());
@@ -307,7 +278,7 @@ void Parser::Parse()
                 continue;
             }
             // light object
-            if (TokenMatch(filePtr,"LIGHTOBJECT",11))
+            if (TokenMatch(filePtr, "LIGHTOBJECT", 11))
 
             {
                 m_vLights.push_back(Light("UNNAMED"));
@@ -315,23 +286,20 @@ void Parser::Parse()
                 continue;
             }
             // camera object
-            if (TokenMatch(filePtr,"CAMERAOBJECT",12))
-            {
+            if (TokenMatch(filePtr, "CAMERAOBJECT", 12)) {
                 m_vCameras.push_back(Camera("UNNAMED"));
                 ParseLV1ObjectBlock(m_vCameras.back());
                 continue;
             }
             // comment - print it on the console
-            if (TokenMatch(filePtr,"COMMENT",7))
-            {
+            if (TokenMatch(filePtr, "COMMENT", 7)) {
                 std::string out = "<unknown>";
-                ParseString(out,"*COMMENT");
+                ParseString(out, "*COMMENT");
                 LogInfo(("Comment: " + out).c_str());
                 continue;
             }
             // ASC bone weights
-            if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(filePtr,"MESH_SOFTSKINVERTS",18))
-            {
+            if (AI_ASE_IS_OLD_FILE_FORMAT() && TokenMatch(filePtr, "MESH_SOFTSKINVERTS", 18)) {
                 ParseLV1SoftSkinBlock();
             }
         }
@@ -341,8 +309,7 @@ void Parser::Parse()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1SoftSkinBlock()
-{
+void Parser::ParseLV1SoftSkinBlock() {
     // TODO: fix line counting here
 
     // **************************************************************
@@ -364,80 +331,77 @@ void Parser::ParseLV1SoftSkinBlock()
     FORMAT END
     */
     // **************************************************************
-    while (true)
-    {
-        if (*filePtr == '}'      )  {++filePtr;return;}
-        else if (*filePtr == '\0')  return;
-        else if (*filePtr == '{' )  ++filePtr;
+    while (true) {
+        if (*filePtr == '}') {
+            ++filePtr;
+            return;
+        } else if (*filePtr == '\0')
+            return;
+        else if (*filePtr == '{')
+            ++filePtr;
 
         else // if (!IsSpace(*filePtr) && !IsLineEnd(*filePtr))
         {
-            ASE::Mesh* curMesh      = NULL;
-            unsigned int numVerts   = 0;
+            ASE::Mesh *curMesh = nullptr;
+            unsigned int numVerts = 0;
 
-            const char* sz = filePtr;
-            while (!IsSpaceOrNewLine(*filePtr))++filePtr;
+            const char *sz = filePtr;
+            while (!IsSpaceOrNewLine(*filePtr))
+                ++filePtr;
 
-            const unsigned int diff = (unsigned int)(filePtr-sz);
-            if (diff)
-            {
-                std::string name = std::string(sz,diff);
+            const unsigned int diff = (unsigned int)(filePtr - sz);
+            if (diff) {
+                std::string name = std::string(sz, diff);
                 for (std::vector<ASE::Mesh>::iterator it = m_vMeshes.begin();
-                    it != m_vMeshes.end(); ++it)
-                {
-                    if ((*it).mName == name)
-                    {
-                        curMesh = & (*it);
+                        it != m_vMeshes.end(); ++it) {
+                    if ((*it).mName == name) {
+                        curMesh = &(*it);
                         break;
                     }
                 }
-                if (!curMesh)
-                {
+                if (!curMesh) {
                     LogWarning("Encountered unknown mesh in *MESH_SOFTSKINVERTS section");
 
                     // Skip the mesh data - until we find a new mesh
                     // or the end of the *MESH_SOFTSKINVERTS section
-                    while (true)
-                    {
+                    while (true) {
                         SkipSpacesAndLineEnd(&filePtr);
-                        if (*filePtr == '}')
-                            {++filePtr;return;}
-                        else if (!IsNumeric(*filePtr))
+                        if (*filePtr == '}') {
+                            ++filePtr;
+                            return;
+                        } else if (!IsNumeric(*filePtr))
                             break;
 
                         SkipLine(&filePtr);
                     }
-                }
-                else
-                {
+                } else {
                     SkipSpacesAndLineEnd(&filePtr);
                     ParseLV4MeshLong(numVerts);
 
                     // Reserve enough storage
                     curMesh->mBoneVertices.reserve(numVerts);
 
-                    for (unsigned int i = 0; i < numVerts;++i)
-                    {
+                    for (unsigned int i = 0; i < numVerts; ++i) {
                         SkipSpacesAndLineEnd(&filePtr);
                         unsigned int numWeights;
                         ParseLV4MeshLong(numWeights);
 
                         curMesh->mBoneVertices.push_back(ASE::BoneVertex());
-                        ASE::BoneVertex& vert = curMesh->mBoneVertices.back();
+                        ASE::BoneVertex &vert = curMesh->mBoneVertices.back();
 
                         // Reserve enough storage
                         vert.mBoneWeights.reserve(numWeights);
 
                         std::string bone;
-                        for (unsigned int w = 0; w < numWeights;++w) {
+                        for (unsigned int w = 0; w < numWeights; ++w) {
                             bone.clear();
-                            ParseString(bone,"*MESH_SOFTSKINVERTS.Bone");
+                            ParseString(bone, "*MESH_SOFTSKINVERTS.Bone");
 
                             // Find the bone in the mesh's list
-                            std::pair<int,ai_real> me;
+                            std::pair<int, ai_real> me;
                             me.first = -1;
 
-                            for (unsigned int n = 0; n < curMesh->mBones.size();++n) {
+                            for (unsigned int n = 0; n < curMesh->mBones.size(); ++n) {
                                 if (curMesh->mBones[n].mName == bone) {
                                     me.first = n;
                                     break;
@@ -445,10 +409,10 @@ void Parser::ParseLV1SoftSkinBlock()
                             }
                             if (-1 == me.first) {
                                 // We don't have this bone yet, so add it to the list
-                                me.first = static_cast<int>( curMesh->mBones.size() );
-                                curMesh->mBones.push_back( ASE::Bone( bone ) );
+                                me.first = static_cast<int>(curMesh->mBones.size());
+                                curMesh->mBones.push_back(ASE::Bone(bone));
                             }
-                            ParseLV4MeshFloat( me.second );
+                            ParseLV4MeshFloat(me.second);
 
                             // Add the new bone weight to list
                             vert.mBoneWeights.push_back(me);
@@ -463,45 +427,38 @@ void Parser::ParseLV1SoftSkinBlock()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1SceneBlock()
-{
+void Parser::ParseLV1SceneBlock() {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"SCENE_BACKGROUND_STATIC",23))
+            if (TokenMatch(filePtr, "SCENE_BACKGROUND_STATIC", 23))
 
             {
                 // parse a color triple and assume it is really the bg color
-                ParseLV4MeshFloatTriple( &m_clrBackground.r );
+                ParseLV4MeshFloatTriple(&m_clrBackground.r);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_AMBIENT_STATIC",20))
+            if (TokenMatch(filePtr, "SCENE_AMBIENT_STATIC", 20))
 
             {
                 // parse a color triple and assume it is really the bg color
-                ParseLV4MeshFloatTriple( &m_clrAmbient.r );
+                ParseLV4MeshFloatTriple(&m_clrAmbient.r);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_FIRSTFRAME",16))
-            {
+            if (TokenMatch(filePtr, "SCENE_FIRSTFRAME", 16)) {
                 ParseLV4MeshLong(iFirstFrame);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_LASTFRAME",15))
-            {
+            if (TokenMatch(filePtr, "SCENE_LASTFRAME", 15)) {
                 ParseLV4MeshLong(iLastFrame);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_FRAMESPEED",16))
-            {
+            if (TokenMatch(filePtr, "SCENE_FRAMESPEED", 16)) {
                 ParseLV4MeshLong(iFrameSpeed);
                 continue;
             }
-            if (TokenMatch(filePtr,"SCENE_TICKSPERFRAME",19))
-            {
+            if (TokenMatch(filePtr, "SCENE_TICKSPERFRAME", 19)) {
                 ParseLV4MeshLong(iTicksPerFrame);
                 continue;
             }
@@ -511,38 +468,32 @@ void Parser::ParseLV1SceneBlock()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1MaterialListBlock()
-{
+void Parser::ParseLV1MaterialListBlock() {
     AI_ASE_PARSER_INIT();
 
     unsigned int iMaterialCount = 0;
     unsigned int iOldMaterialCount = (unsigned int)m_vMaterials.size();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"MATERIAL_COUNT",14))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_COUNT", 14)) {
                 ParseLV4MeshLong(iMaterialCount);
 
                 // now allocate enough storage to hold all materials
-                m_vMaterials.resize(iOldMaterialCount+iMaterialCount, Material("INVALID"));
+                m_vMaterials.resize(iOldMaterialCount + iMaterialCount, Material("INVALID"));
                 continue;
             }
-            if (TokenMatch(filePtr,"MATERIAL",8))
-            {
+            if (TokenMatch(filePtr, "MATERIAL", 8)) {
                 unsigned int iIndex = 0;
                 ParseLV4MeshLong(iIndex);
 
-                if (iIndex >= iMaterialCount)
-                {
+                if (iIndex >= iMaterialCount) {
                     LogWarning("Out of range: material index is too large");
-                    iIndex = iMaterialCount-1;
+                    iIndex = iMaterialCount - 1;
                 }
 
                 // get a reference to the material
-                Material& sMat = m_vMaterials[iIndex+iOldMaterialCount];
+                Material &sMat = m_vMaterials[iIndex + iOldMaterialCount];
                 // parse the material block
                 ParseLV2MaterialBlock(sMat);
                 continue;
@@ -553,61 +504,44 @@ void Parser::ParseLV1MaterialListBlock()
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
-{
+void Parser::ParseLV2MaterialBlock(ASE::Material &mat) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumSubMaterials = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"MATERIAL_NAME",13))
-            {
-                if (!ParseString(mat.mName,"*MATERIAL_NAME"))
+            if (TokenMatch(filePtr, "MATERIAL_NAME", 13)) {
+                if (!ParseString(mat.mName, "*MATERIAL_NAME"))
                     SkipToNextToken();
                 continue;
             }
             // ambient material color
-            if (TokenMatch(filePtr,"MATERIAL_AMBIENT",16))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_AMBIENT", 16)) {
                 ParseLV4MeshFloatTriple(&mat.mAmbient.r);
                 continue;
             }
             // diffuse material color
-            if (TokenMatch(filePtr,"MATERIAL_DIFFUSE",16) )
-            {
+            if (TokenMatch(filePtr, "MATERIAL_DIFFUSE", 16)) {
                 ParseLV4MeshFloatTriple(&mat.mDiffuse.r);
                 continue;
             }
             // specular material color
-            if (TokenMatch(filePtr,"MATERIAL_SPECULAR",17))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SPECULAR", 17)) {
                 ParseLV4MeshFloatTriple(&mat.mSpecular.r);
                 continue;
             }
             // material shading type
-            if (TokenMatch(filePtr,"MATERIAL_SHADING",16))
-            {
-                if (TokenMatch(filePtr,"Blinn",5))
-                {
+            if (TokenMatch(filePtr, "MATERIAL_SHADING", 16)) {
+                if (TokenMatch(filePtr, "Blinn", 5)) {
                     mat.mShading = Discreet3DS::Blinn;
-                }
-                else if (TokenMatch(filePtr,"Phong",5))
-                {
+                } else if (TokenMatch(filePtr, "Phong", 5)) {
                     mat.mShading = Discreet3DS::Phong;
-                }
-                else if (TokenMatch(filePtr,"Flat",4))
-                {
+                } else if (TokenMatch(filePtr, "Flat", 4)) {
                     mat.mShading = Discreet3DS::Flat;
-                }
-                else if (TokenMatch(filePtr,"Wire",4))
-                {
+                } else if (TokenMatch(filePtr, "Wire", 4)) {
                     mat.mShading = Discreet3DS::Wire;
-                }
-                else
-                {
+                } else {
                     // assume gouraud shading
                     mat.mShading = Discreet3DS::Gouraud;
                     SkipToNextToken();
@@ -615,15 +549,13 @@ void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
                 continue;
             }
             // material transparency
-            if (TokenMatch(filePtr,"MATERIAL_TRANSPARENCY",21))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_TRANSPARENCY", 21)) {
                 ParseLV4MeshFloat(mat.mTransparency);
-                mat.mTransparency = ai_real( 1.0 ) - mat.mTransparency;
+                mat.mTransparency = ai_real(1.0) - mat.mTransparency;
                 continue;
             }
             // material self illumination
-            if (TokenMatch(filePtr,"MATERIAL_SELFILLUM",18))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SELFILLUM", 18)) {
                 ai_real f = 0.0;
                 ParseLV4MeshFloat(f);
 
@@ -633,108 +565,94 @@ void Parser::ParseLV2MaterialBlock(ASE::Material& mat)
                 continue;
             }
             // material shininess
-            if (TokenMatch(filePtr,"MATERIAL_SHINE",14) )
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SHINE", 14)) {
                 ParseLV4MeshFloat(mat.mSpecularExponent);
                 mat.mSpecularExponent *= 15;
                 continue;
             }
             // two-sided material
-            if (TokenMatch(filePtr,"MATERIAL_TWOSIDED",17) )
-            {
+            if (TokenMatch(filePtr, "MATERIAL_TWOSIDED", 17)) {
                 mat.mTwoSided = true;
                 continue;
             }
             // material shininess strength
-            if (TokenMatch(filePtr,"MATERIAL_SHINESTRENGTH",22))
-            {
+            if (TokenMatch(filePtr, "MATERIAL_SHINESTRENGTH", 22)) {
                 ParseLV4MeshFloat(mat.mShininessStrength);
                 continue;
             }
             // diffuse color map
-            if (TokenMatch(filePtr,"MAP_DIFFUSE",11))
-            {
+            if (TokenMatch(filePtr, "MAP_DIFFUSE", 11)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexDiffuse);
                 continue;
             }
             // ambient color map
-            if (TokenMatch(filePtr,"MAP_AMBIENT",11))
-            {
+            if (TokenMatch(filePtr, "MAP_AMBIENT", 11)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexAmbient);
                 continue;
             }
             // specular color map
-            if (TokenMatch(filePtr,"MAP_SPECULAR",12))
-            {
+            if (TokenMatch(filePtr, "MAP_SPECULAR", 12)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexSpecular);
                 continue;
             }
             // opacity map
-            if (TokenMatch(filePtr,"MAP_OPACITY",11))
-            {
+            if (TokenMatch(filePtr, "MAP_OPACITY", 11)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexOpacity);
                 continue;
             }
             // emissive map
-            if (TokenMatch(filePtr,"MAP_SELFILLUM",13))
-            {
+            if (TokenMatch(filePtr, "MAP_SELFILLUM", 13)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexEmissive);
                 continue;
             }
             // bump map
-            if (TokenMatch(filePtr,"MAP_BUMP",8))
-            {
+            if (TokenMatch(filePtr, "MAP_BUMP", 8)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexBump);
             }
             // specular/shininess map
-            if (TokenMatch(filePtr,"MAP_SHINESTRENGTH",17))
-            {
+            if (TokenMatch(filePtr, "MAP_SHINESTRENGTH", 17)) {
                 // parse the texture block
                 ParseLV3MapBlock(mat.sTexShininess);
                 continue;
             }
             // number of submaterials
-            if (TokenMatch(filePtr,"NUMSUBMTLS",10))
-            {
+            if (TokenMatch(filePtr, "NUMSUBMTLS", 10)) {
                 ParseLV4MeshLong(iNumSubMaterials);
 
                 // allocate enough storage
                 mat.avSubMaterials.resize(iNumSubMaterials, Material("INVALID SUBMATERIAL"));
             }
             // submaterial chunks
-            if (TokenMatch(filePtr,"SUBMATERIAL",11))
-            {
+            if (TokenMatch(filePtr, "SUBMATERIAL", 11)) {
 
                 unsigned int iIndex = 0;
                 ParseLV4MeshLong(iIndex);
 
-                if (iIndex >= iNumSubMaterials)
-                {
+                if (iIndex >= iNumSubMaterials) {
                     LogWarning("Out of range: submaterial index is too large");
-                    iIndex = iNumSubMaterials-1;
+                    iIndex = iNumSubMaterials - 1;
                 }
 
                 // get a reference to the material
-                Material& sMat = mat.avSubMaterials[iIndex];
+                Material &sMat = mat.avSubMaterials[iIndex];
 
                 // parse the material block
                 ParseLV2MaterialBlock(sMat);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","*MATERIAL");
+        AI_ASE_HANDLE_SECTION("2", "*MATERIAL");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MapBlock(Texture& map)
-{
+void Parser::ParseLV3MapBlock(Texture &map) {
     AI_ASE_PARSER_INIT();
 
     // ***********************************************************
@@ -744,32 +662,26 @@ void Parser::ParseLV3MapBlock(Texture& map)
     // ***********************************************************
     bool parsePath = true;
     std::string temp;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
             // type of map
-            if (TokenMatch(filePtr,"MAP_CLASS" ,9))
-            {
+            if (TokenMatch(filePtr, "MAP_CLASS", 9)) {
                 temp.clear();
-                if(!ParseString(temp,"*MAP_CLASS"))
+                if (!ParseString(temp, "*MAP_CLASS"))
                     SkipToNextToken();
-                if (temp != "Bitmap" && temp != "Normal Bump")
-                {
+                if (temp != "Bitmap" && temp != "Normal Bump") {
                     ASSIMP_LOG_WARN_F("ASE: Skipping unknown map type: ", temp);
                     parsePath = false;
                 }
                 continue;
             }
             // path to the texture
-            if (parsePath && TokenMatch(filePtr,"BITMAP" ,6))
-            {
-                if(!ParseString(map.mMapName,"*BITMAP"))
+            if (parsePath && TokenMatch(filePtr, "BITMAP", 6)) {
+                if (!ParseString(map.mMapName, "*BITMAP"))
                     SkipToNextToken();
 
-                if (map.mMapName == "None")
-                {
+                if (map.mMapName == "None") {
                     // Files with 'None' as map name are produced by
                     // an Maja to ASE exporter which name I forgot ..
                     ASSIMP_LOG_WARN("ASE: Skipping invalid map entry");
@@ -779,198 +691,157 @@ void Parser::ParseLV3MapBlock(Texture& map)
                 continue;
             }
             // offset on the u axis
-            if (TokenMatch(filePtr,"UVW_U_OFFSET" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_U_OFFSET", 12)) {
                 ParseLV4MeshFloat(map.mOffsetU);
                 continue;
             }
             // offset on the v axis
-            if (TokenMatch(filePtr,"UVW_V_OFFSET" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_V_OFFSET", 12)) {
                 ParseLV4MeshFloat(map.mOffsetV);
                 continue;
             }
             // tiling on the u axis
-            if (TokenMatch(filePtr,"UVW_U_TILING" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_U_TILING", 12)) {
                 ParseLV4MeshFloat(map.mScaleU);
                 continue;
             }
             // tiling on the v axis
-            if (TokenMatch(filePtr,"UVW_V_TILING" ,12))
-            {
+            if (TokenMatch(filePtr, "UVW_V_TILING", 12)) {
                 ParseLV4MeshFloat(map.mScaleV);
                 continue;
             }
             // rotation around the z-axis
-            if (TokenMatch(filePtr,"UVW_ANGLE" ,9))
-            {
+            if (TokenMatch(filePtr, "UVW_ANGLE", 9)) {
                 ParseLV4MeshFloat(map.mRotation);
                 continue;
             }
             // map blending factor
-            if (TokenMatch(filePtr,"MAP_AMOUNT" ,10))
-            {
+            if (TokenMatch(filePtr, "MAP_AMOUNT", 10)) {
                 ParseLV4MeshFloat(map.mTextureBlend);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MAP_XXXXXX");
+        AI_ASE_HANDLE_SECTION("3", "*MAP_XXXXXX");
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
-bool Parser::ParseString(std::string& out,const char* szName)
-{
+bool Parser::ParseString(std::string &out, const char *szName) {
     char szBuffer[1024];
-    if (!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
 
-        ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL",szName);
+        ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Unexpected EOL", szName);
         LogWarning(szBuffer);
         return false;
     }
     // there must be '"'
-    if ('\"' != *filePtr)
-    {
+    if ('\"' != *filePtr) {
 
         ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected "
-            "to be enclosed in double quotation marks",szName);
+                                    "to be enclosed in double quotation marks",
+                szName);
         LogWarning(szBuffer);
         return false;
     }
     ++filePtr;
-    const char* sz = filePtr;
-    while (true)
-    {
-        if ('\"' == *sz)break;
-        else if ('\0' == *sz)
-        {
+    const char *sz = filePtr;
+    while (true) {
+        if ('\"' == *sz)
+            break;
+        else if ('\0' == *sz) {
             ai_snprintf(szBuffer, 1024, "Unable to parse %s block: Strings are expected to "
-                "be enclosed in double quotation marks but EOF was reached before "
-                "a closing quotation mark was encountered",szName);
+                                        "be enclosed in double quotation marks but EOF was reached before "
+                                        "a closing quotation mark was encountered",
+                    szName);
             LogWarning(szBuffer);
             return false;
         }
         sz++;
     }
-    out = std::string(filePtr,(uintptr_t)sz-(uintptr_t)filePtr);
-    filePtr = sz+1;
+    out = std::string(filePtr, (uintptr_t)sz - (uintptr_t)filePtr);
+    filePtr = sz + 1;
     return true;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV1ObjectBlock(ASE::BaseNode& node)
-{
+void Parser::ParseLV1ObjectBlock(ASE::BaseNode &node) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // first process common tokens such as node name and transform
             // name of the mesh/node
-            if (TokenMatch(filePtr,"NODE_NAME" ,9))
-            {
-                if(!ParseString(node.mName,"*NODE_NAME"))
+            if (TokenMatch(filePtr, "NODE_NAME", 9)) {
+                if (!ParseString(node.mName, "*NODE_NAME"))
                     SkipToNextToken();
                 continue;
             }
             // name of the parent of the node
-            if (TokenMatch(filePtr,"NODE_PARENT" ,11) )
-            {
-                if(!ParseString(node.mParent,"*NODE_PARENT"))
+            if (TokenMatch(filePtr, "NODE_PARENT", 11)) {
+                if (!ParseString(node.mParent, "*NODE_PARENT"))
                     SkipToNextToken();
                 continue;
             }
             // transformation matrix of the node
-            if (TokenMatch(filePtr,"NODE_TM" ,7))
-            {
+            if (TokenMatch(filePtr, "NODE_TM", 7)) {
                 ParseLV2NodeTransformBlock(node);
                 continue;
             }
             // animation data of the node
-            if (TokenMatch(filePtr,"TM_ANIMATION" ,12))
-            {
+            if (TokenMatch(filePtr, "TM_ANIMATION", 12)) {
                 ParseLV2AnimationBlock(node);
                 continue;
             }
 
-            if (node.mType == BaseNode::Light)
-            {
+            if (node.mType == BaseNode::Light) {
                 // light settings
-                if (TokenMatch(filePtr,"LIGHT_SETTINGS" ,14))
-                {
-                    ParseLV2LightSettingsBlock((ASE::Light&)node);
+                if (TokenMatch(filePtr, "LIGHT_SETTINGS", 14)) {
+                    ParseLV2LightSettingsBlock((ASE::Light &)node);
                     continue;
                 }
                 // type of the light source
-                if (TokenMatch(filePtr,"LIGHT_TYPE" ,10))
-                {
-                    if (!ASSIMP_strincmp("omni",filePtr,4))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::OMNI;
-                    }
-                    else if (!ASSIMP_strincmp("target",filePtr,6))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::TARGET;
-                    }
-                    else if (!ASSIMP_strincmp("free",filePtr,4))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::FREE;
-                    }
-                    else if (!ASSIMP_strincmp("directional",filePtr,11))
-                    {
-                        ((ASE::Light&)node).mLightType = ASE::Light::DIRECTIONAL;
-                    }
-                    else
-                    {
+                if (TokenMatch(filePtr, "LIGHT_TYPE", 10)) {
+                    if (!ASSIMP_strincmp("omni", filePtr, 4)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::OMNI;
+                    } else if (!ASSIMP_strincmp("target", filePtr, 6)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::TARGET;
+                    } else if (!ASSIMP_strincmp("free", filePtr, 4)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::FREE;
+                    } else if (!ASSIMP_strincmp("directional", filePtr, 11)) {
+                        ((ASE::Light &)node).mLightType = ASE::Light::DIRECTIONAL;
+                    } else {
                         LogWarning("Unknown kind of light source");
                     }
                     continue;
                 }
-            }
-            else if (node.mType == BaseNode::Camera)
-            {
+            } else if (node.mType == BaseNode::Camera) {
                 // Camera settings
-                if (TokenMatch(filePtr,"CAMERA_SETTINGS" ,15))
-                {
-                    ParseLV2CameraSettingsBlock((ASE::Camera&)node);
+                if (TokenMatch(filePtr, "CAMERA_SETTINGS", 15)) {
+                    ParseLV2CameraSettingsBlock((ASE::Camera &)node);
                     continue;
-                }
-                else if (TokenMatch(filePtr,"CAMERA_TYPE" ,11))
-                {
-                    if (!ASSIMP_strincmp("target",filePtr,6))
-                    {
-                        ((ASE::Camera&)node).mCameraType = ASE::Camera::TARGET;
-                    }
-                    else if (!ASSIMP_strincmp("free",filePtr,4))
-                    {
-                        ((ASE::Camera&)node).mCameraType = ASE::Camera::FREE;
-                    }
-                    else
-                    {
+                } else if (TokenMatch(filePtr, "CAMERA_TYPE", 11)) {
+                    if (!ASSIMP_strincmp("target", filePtr, 6)) {
+                        ((ASE::Camera &)node).mCameraType = ASE::Camera::TARGET;
+                    } else if (!ASSIMP_strincmp("free", filePtr, 4)) {
+                        ((ASE::Camera &)node).mCameraType = ASE::Camera::FREE;
+                    } else {
                         LogWarning("Unknown kind of camera");
                     }
                     continue;
                 }
-            }
-            else if (node.mType == BaseNode::Mesh)
-            {
+            } else if (node.mType == BaseNode::Mesh) {
                 // mesh data
                 // FIX: Older files use MESH_SOFTSKIN
-                if (TokenMatch(filePtr,"MESH" ,4) ||
-                    TokenMatch(filePtr,"MESH_SOFTSKIN",13))
-                {
-                    ParseLV2MeshBlock((ASE::Mesh&)node);
+                if (TokenMatch(filePtr, "MESH", 4) ||
+                        TokenMatch(filePtr, "MESH_SOFTSKIN", 13)) {
+                    ParseLV2MeshBlock((ASE::Mesh &)node);
                     continue;
                 }
                 // mesh material index
-                if (TokenMatch(filePtr,"MATERIAL_REF" ,12))
-                {
-                    ParseLV4MeshLong(((ASE::Mesh&)node).iMaterialIndex);
+                if (TokenMatch(filePtr, "MATERIAL_REF", 12)) {
+                    ParseLV4MeshLong(((ASE::Mesh &)node).iMaterialIndex);
                     continue;
                 }
             }
@@ -981,156 +852,131 @@ void Parser::ParseLV1ObjectBlock(ASE::BaseNode& node)
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2CameraSettingsBlock(ASE::Camera& camera)
-{
+void Parser::ParseLV2CameraSettingsBlock(ASE::Camera &camera) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"CAMERA_NEAR" ,11))
-            {
+            if (TokenMatch(filePtr, "CAMERA_NEAR", 11)) {
                 ParseLV4MeshFloat(camera.mNear);
                 continue;
             }
-            if (TokenMatch(filePtr,"CAMERA_FAR" ,10))
-            {
+            if (TokenMatch(filePtr, "CAMERA_FAR", 10)) {
                 ParseLV4MeshFloat(camera.mFar);
                 continue;
             }
-            if (TokenMatch(filePtr,"CAMERA_FOV" ,10))
-            {
+            if (TokenMatch(filePtr, "CAMERA_FOV", 10)) {
                 ParseLV4MeshFloat(camera.mFOV);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","CAMERA_SETTINGS");
+        AI_ASE_HANDLE_SECTION("2", "CAMERA_SETTINGS");
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2LightSettingsBlock(ASE::Light& light)
-{
+void Parser::ParseLV2LightSettingsBlock(ASE::Light &light) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"LIGHT_COLOR" ,11))
-            {
+            if (TokenMatch(filePtr, "LIGHT_COLOR", 11)) {
                 ParseLV4MeshFloatTriple(&light.mColor.r);
                 continue;
             }
-            if (TokenMatch(filePtr,"LIGHT_INTENS" ,12))
-            {
+            if (TokenMatch(filePtr, "LIGHT_INTENS", 12)) {
                 ParseLV4MeshFloat(light.mIntensity);
                 continue;
             }
-            if (TokenMatch(filePtr,"LIGHT_HOTSPOT" ,13))
-            {
+            if (TokenMatch(filePtr, "LIGHT_HOTSPOT", 13)) {
                 ParseLV4MeshFloat(light.mAngle);
                 continue;
             }
-            if (TokenMatch(filePtr,"LIGHT_FALLOFF" ,13))
-            {
+            if (TokenMatch(filePtr, "LIGHT_FALLOFF", 13)) {
                 ParseLV4MeshFloat(light.mFalloff);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","LIGHT_SETTINGS");
+        AI_ASE_HANDLE_SECTION("2", "LIGHT_SETTINGS");
     }
     return;
 }
 
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2AnimationBlock(ASE::BaseNode& mesh)
-{
+void Parser::ParseLV2AnimationBlock(ASE::BaseNode &mesh) {
     AI_ASE_PARSER_INIT();
 
-    ASE::Animation* anim = &mesh.mAnim;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    ASE::Animation *anim = &mesh.mAnim;
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (TokenMatch(filePtr,"NODE_NAME" ,9))
-            {
+            if (TokenMatch(filePtr, "NODE_NAME", 9)) {
                 std::string temp;
-                if(!ParseString(temp,"*NODE_NAME"))
+                if (!ParseString(temp, "*NODE_NAME"))
                     SkipToNextToken();
 
                 // If the name of the node contains .target it
                 // represents an animated camera or spot light
                 // target.
-                if (std::string::npos != temp.find(".Target"))
-                {
-                    if  ((mesh.mType != BaseNode::Camera || ((ASE::Camera&)mesh).mCameraType != ASE::Camera::TARGET)  &&
-                        ( mesh.mType != BaseNode::Light  || ((ASE::Light&)mesh).mLightType   != ASE::Light::TARGET))
-                    {
+                if (std::string::npos != temp.find(".Target")) {
+                    if ((mesh.mType != BaseNode::Camera || ((ASE::Camera &)mesh).mCameraType != ASE::Camera::TARGET) &&
+                            (mesh.mType != BaseNode::Light || ((ASE::Light &)mesh).mLightType != ASE::Light::TARGET)) {
 
                         ASSIMP_LOG_ERROR("ASE: Found target animation channel "
-                            "but the node is neither a camera nor a spot light");
+                                         "but the node is neither a camera nor a spot light");
                         anim = NULL;
-                    }
-                    else anim = &mesh.mTargetAnim;
+                    } else
+                        anim = &mesh.mTargetAnim;
                 }
                 continue;
             }
 
             // position keyframes
-            if (TokenMatch(filePtr,"CONTROL_POS_TRACK"  ,17)  ||
-                TokenMatch(filePtr,"CONTROL_POS_BEZIER" ,18)  ||
-                TokenMatch(filePtr,"CONTROL_POS_TCB"    ,15))
-            {
-                if (!anim)SkipSection();
-                else ParseLV3PosAnimationBlock(*anim);
+            if (TokenMatch(filePtr, "CONTROL_POS_TRACK", 17) ||
+                    TokenMatch(filePtr, "CONTROL_POS_BEZIER", 18) ||
+                    TokenMatch(filePtr, "CONTROL_POS_TCB", 15)) {
+                if (!anim)
+                    SkipSection();
+                else
+                    ParseLV3PosAnimationBlock(*anim);
                 continue;
             }
             // scaling keyframes
-            if (TokenMatch(filePtr,"CONTROL_SCALE_TRACK"  ,19) ||
-                TokenMatch(filePtr,"CONTROL_SCALE_BEZIER" ,20) ||
-                TokenMatch(filePtr,"CONTROL_SCALE_TCB"    ,17))
-            {
-                if (!anim || anim == &mesh.mTargetAnim)
-                {
+            if (TokenMatch(filePtr, "CONTROL_SCALE_TRACK", 19) ||
+                    TokenMatch(filePtr, "CONTROL_SCALE_BEZIER", 20) ||
+                    TokenMatch(filePtr, "CONTROL_SCALE_TCB", 17)) {
+                if (!anim || anim == &mesh.mTargetAnim) {
                     // Target animation channels may have no rotation channels
                     ASSIMP_LOG_ERROR("ASE: Ignoring scaling channel in target animation");
                     SkipSection();
-                }
-                else ParseLV3ScaleAnimationBlock(*anim);
+                } else
+                    ParseLV3ScaleAnimationBlock(*anim);
                 continue;
             }
             // rotation keyframes
-            if (TokenMatch(filePtr,"CONTROL_ROT_TRACK"  ,17) ||
-                TokenMatch(filePtr,"CONTROL_ROT_BEZIER" ,18) ||
-                TokenMatch(filePtr,"CONTROL_ROT_TCB"    ,15))
-            {
-                if (!anim || anim == &mesh.mTargetAnim)
-                {
+            if (TokenMatch(filePtr, "CONTROL_ROT_TRACK", 17) ||
+                    TokenMatch(filePtr, "CONTROL_ROT_BEZIER", 18) ||
+                    TokenMatch(filePtr, "CONTROL_ROT_TCB", 15)) {
+                if (!anim || anim == &mesh.mTargetAnim) {
                     // Target animation channels may have no rotation channels
                     ASSIMP_LOG_ERROR("ASE: Ignoring rotation channel in target animation");
                     SkipSection();
-                }
-                else ParseLV3RotAnimationBlock(*anim);
+                } else
+                    ParseLV3RotAnimationBlock(*anim);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","TM_ANIMATION");
+        AI_ASE_HANDLE_SECTION("2", "TM_ANIMATION");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation& anim)
-{
+void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation &anim) {
     AI_ASE_PARSER_INIT();
     unsigned int iIndex;
 
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             bool b = false;
@@ -1139,44 +985,37 @@ void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation& anim)
             // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_SCALE_SAMPLE" ,20))
-            {
+            if (TokenMatch(filePtr, "CONTROL_SCALE_SAMPLE", 20)) {
                 b = true;
                 anim.mScalingType = ASE::Animation::TRACK;
             }
 
             // Bezier scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_BEZIER_SCALE_KEY" ,24))
-            {
+            if (TokenMatch(filePtr, "CONTROL_BEZIER_SCALE_KEY", 24)) {
                 b = true;
                 anim.mScalingType = ASE::Animation::BEZIER;
             }
             // TCB scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_TCB_SCALE_KEY" ,21))
-            {
+            if (TokenMatch(filePtr, "CONTROL_TCB_SCALE_KEY", 21)) {
                 b = true;
                 anim.mScalingType = ASE::Animation::TCB;
             }
-            if (b)
-            {
+            if (b) {
                 anim.akeyScaling.push_back(aiVectorKey());
-                aiVectorKey& key = anim.akeyScaling.back();
-                ParseLV4MeshFloatTriple(&key.mValue.x,iIndex);
+                aiVectorKey &key = anim.akeyScaling.back();
+                ParseLV4MeshFloatTriple(&key.mValue.x, iIndex);
                 key.mTime = (double)iIndex;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*CONTROL_POS_TRACK");
+        AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3PosAnimationBlock(ASE::Animation& anim)
-{
+void Parser::ParseLV3PosAnimationBlock(ASE::Animation &anim) {
     AI_ASE_PARSER_INIT();
     unsigned int iIndex;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             bool b = false;
@@ -1185,44 +1024,37 @@ void Parser::ParseLV3PosAnimationBlock(ASE::Animation& anim)
             // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_POS_SAMPLE" ,18))
-            {
+            if (TokenMatch(filePtr, "CONTROL_POS_SAMPLE", 18)) {
                 b = true;
                 anim.mPositionType = ASE::Animation::TRACK;
             }
 
             // Bezier scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_BEZIER_POS_KEY" ,22))
-            {
+            if (TokenMatch(filePtr, "CONTROL_BEZIER_POS_KEY", 22)) {
                 b = true;
                 anim.mPositionType = ASE::Animation::BEZIER;
             }
             // TCB scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_TCB_POS_KEY" ,19))
-            {
+            if (TokenMatch(filePtr, "CONTROL_TCB_POS_KEY", 19)) {
                 b = true;
                 anim.mPositionType = ASE::Animation::TCB;
             }
-            if (b)
-            {
+            if (b) {
                 anim.akeyPositions.push_back(aiVectorKey());
-                aiVectorKey& key = anim.akeyPositions.back();
-                ParseLV4MeshFloatTriple(&key.mValue.x,iIndex);
+                aiVectorKey &key = anim.akeyPositions.back();
+                ParseLV4MeshFloatTriple(&key.mValue.x, iIndex);
                 key.mTime = (double)iIndex;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*CONTROL_POS_TRACK");
+        AI_ASE_HANDLE_SECTION("3", "*CONTROL_POS_TRACK");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3RotAnimationBlock(ASE::Animation& anim)
-{
+void Parser::ParseLV3RotAnimationBlock(ASE::Animation &anim) {
     AI_ASE_PARSER_INIT();
     unsigned int iIndex;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             bool b = false;
@@ -1231,150 +1063,126 @@ void Parser::ParseLV3RotAnimationBlock(ASE::Animation& anim)
             // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_ROT_SAMPLE" ,18))
-            {
+            if (TokenMatch(filePtr, "CONTROL_ROT_SAMPLE", 18)) {
                 b = true;
                 anim.mRotationType = ASE::Animation::TRACK;
             }
 
             // Bezier scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_BEZIER_ROT_KEY" ,22))
-            {
+            if (TokenMatch(filePtr, "CONTROL_BEZIER_ROT_KEY", 22)) {
                 b = true;
                 anim.mRotationType = ASE::Animation::BEZIER;
             }
             // TCB scaling keyframe
-            if (TokenMatch(filePtr,"CONTROL_TCB_ROT_KEY" ,19))
-            {
+            if (TokenMatch(filePtr, "CONTROL_TCB_ROT_KEY", 19)) {
                 b = true;
                 anim.mRotationType = ASE::Animation::TCB;
             }
-            if (b)
-            {
+            if (b) {
                 anim.akeyRotations.push_back(aiQuatKey());
-                aiQuatKey& key = anim.akeyRotations.back();
-                aiVector3D v;ai_real f;
-                ParseLV4MeshFloatTriple(&v.x,iIndex);
+                aiQuatKey &key = anim.akeyRotations.back();
+                aiVector3D v;
+                ai_real f;
+                ParseLV4MeshFloatTriple(&v.x, iIndex);
                 ParseLV4MeshFloat(f);
                 key.mTime = (double)iIndex;
-                key.mValue = aiQuaternion(v,f);
+                key.mValue = aiQuaternion(v, f);
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*CONTROL_ROT_TRACK");
+        AI_ASE_HANDLE_SECTION("3", "*CONTROL_ROT_TRACK");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode& mesh)
-{
+void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode &mesh) {
     AI_ASE_PARSER_INIT();
-    int mode   = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    int mode = 0;
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
             // name of the node
-            if (TokenMatch(filePtr,"NODE_NAME" ,9))
-            {
+            if (TokenMatch(filePtr, "NODE_NAME", 9)) {
                 std::string temp;
-                if(!ParseString(temp,"*NODE_NAME"))
+                if (!ParseString(temp, "*NODE_NAME"))
                     SkipToNextToken();
 
                 std::string::size_type s;
-                if (temp == mesh.mName)
-                {
+                if (temp == mesh.mName) {
                     mode = 1;
-                }
-                else if (std::string::npos != (s = temp.find(".Target")) &&
-                    mesh.mName == temp.substr(0,s))
-                {
+                } else if (std::string::npos != (s = temp.find(".Target")) &&
+                           mesh.mName == temp.substr(0, s)) {
                     // This should be either a target light or a target camera
-                    if ( (mesh.mType == BaseNode::Light &&  ((ASE::Light&)mesh) .mLightType  == ASE::Light::TARGET) ||
-                         (mesh.mType == BaseNode::Camera && ((ASE::Camera&)mesh).mCameraType == ASE::Camera::TARGET))
-                    {
+                    if ((mesh.mType == BaseNode::Light && ((ASE::Light &)mesh).mLightType == ASE::Light::TARGET) ||
+                            (mesh.mType == BaseNode::Camera && ((ASE::Camera &)mesh).mCameraType == ASE::Camera::TARGET)) {
                         mode = 2;
-                    }
-                    else {
+                    } else {
                         ASSIMP_LOG_ERROR("ASE: Ignoring target transform, "
-                            "this is no spot light or target camera");
+                                         "this is no spot light or target camera");
                     }
-                }
-                else
-                {
+                } else {
                     ASSIMP_LOG_ERROR("ASE: Unknown node transformation: " + temp);
                     // mode = 0
                 }
                 continue;
             }
-            if (mode)
-            {
+            if (mode) {
                 // fourth row of the transformation matrix - and also the
                 // only information here that is interesting for targets
-                if (TokenMatch(filePtr,"TM_ROW3" ,7))
-                {
+                if (TokenMatch(filePtr, "TM_ROW3", 7)) {
                     ParseLV4MeshFloatTriple((mode == 1 ? mesh.mTransform[3] : &mesh.mTargetPosition.x));
                     continue;
                 }
-                if (mode == 1)
-                {
+                if (mode == 1) {
                     // first row of the transformation matrix
-                    if (TokenMatch(filePtr,"TM_ROW0" ,7))
-                    {
+                    if (TokenMatch(filePtr, "TM_ROW0", 7)) {
                         ParseLV4MeshFloatTriple(mesh.mTransform[0]);
                         continue;
                     }
                     // second row of the transformation matrix
-                    if (TokenMatch(filePtr,"TM_ROW1" ,7))
-                    {
+                    if (TokenMatch(filePtr, "TM_ROW1", 7)) {
                         ParseLV4MeshFloatTriple(mesh.mTransform[1]);
                         continue;
                     }
                     // third row of the transformation matrix
-                    if (TokenMatch(filePtr,"TM_ROW2" ,7))
-                    {
+                    if (TokenMatch(filePtr, "TM_ROW2", 7)) {
                         ParseLV4MeshFloatTriple(mesh.mTransform[2]);
                         continue;
                     }
                     // inherited position axes
-                    if (TokenMatch(filePtr,"INHERIT_POS" ,11))
-                    {
+                    if (TokenMatch(filePtr, "INHERIT_POS", 11)) {
                         unsigned int aiVal[3];
                         ParseLV4MeshLongTriple(aiVal);
 
-                        for (unsigned int i = 0; i < 3;++i)
+                        for (unsigned int i = 0; i < 3; ++i)
                             mesh.inherit.abInheritPosition[i] = aiVal[i] != 0;
                         continue;
                     }
                     // inherited rotation axes
-                    if (TokenMatch(filePtr,"INHERIT_ROT" ,11))
-                    {
+                    if (TokenMatch(filePtr, "INHERIT_ROT", 11)) {
                         unsigned int aiVal[3];
                         ParseLV4MeshLongTriple(aiVal);
 
-                        for (unsigned int i = 0; i < 3;++i)
+                        for (unsigned int i = 0; i < 3; ++i)
                             mesh.inherit.abInheritRotation[i] = aiVal[i] != 0;
                         continue;
                     }
                     // inherited scaling axes
-                    if (TokenMatch(filePtr,"INHERIT_SCL" ,11))
-                    {
+                    if (TokenMatch(filePtr, "INHERIT_SCL", 11)) {
                         unsigned int aiVal[3];
                         ParseLV4MeshLongTriple(aiVal);
 
-                        for (unsigned int i = 0; i < 3;++i)
+                        for (unsigned int i = 0; i < 3; ++i)
                             mesh.inherit.abInheritScaling[i] = aiVal[i] != 0;
                         continue;
                     }
                 }
             }
         }
-        AI_ASE_HANDLE_SECTION("2","*NODE_TM");
+        AI_ASE_HANDLE_SECTION("2", "*NODE_TM");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV2MeshBlock(ASE::Mesh& mesh)
-{
+void Parser::ParseLV2MeshBlock(ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumVertices = 0;
@@ -1383,386 +1191,327 @@ void Parser::ParseLV2MeshBlock(ASE::Mesh& mesh)
     unsigned int iNumTFaces = 0;
     unsigned int iNumCVertices = 0;
     unsigned int iNumCFaces = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
             // Number of vertices in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMVERTEX" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMVERTEX", 14)) {
                 ParseLV4MeshLong(iNumVertices);
                 continue;
             }
             // Number of texture coordinates in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVERTEX" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVERTEX", 15)) {
                 ParseLV4MeshLong(iNumTVertices);
                 continue;
             }
             // Number of vertex colors in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMCVERTEX" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMCVERTEX", 15)) {
                 ParseLV4MeshLong(iNumCVertices);
                 continue;
             }
             // Number of regular faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMFACES" ,13))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMFACES", 13)) {
                 ParseLV4MeshLong(iNumFaces);
                 continue;
             }
             // Number of UVWed faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVFACES" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVFACES", 15)) {
                 ParseLV4MeshLong(iNumTFaces);
                 continue;
             }
             // Number of colored faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMCVFACES" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMCVFACES", 15)) {
                 ParseLV4MeshLong(iNumCFaces);
                 continue;
             }
             // mesh vertex list block
-            if (TokenMatch(filePtr,"MESH_VERTEX_LIST" ,16))
-            {
-                ParseLV3MeshVertexListBlock(iNumVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_VERTEX_LIST", 16)) {
+                ParseLV3MeshVertexListBlock(iNumVertices, mesh);
                 continue;
             }
             // mesh face list block
-            if (TokenMatch(filePtr,"MESH_FACE_LIST" ,14))
-            {
-                ParseLV3MeshFaceListBlock(iNumFaces,mesh);
+            if (TokenMatch(filePtr, "MESH_FACE_LIST", 14)) {
+                ParseLV3MeshFaceListBlock(iNumFaces, mesh);
                 continue;
             }
             // mesh texture vertex list block
-            if (TokenMatch(filePtr,"MESH_TVERTLIST" ,14))
-            {
-                ParseLV3MeshTListBlock(iNumTVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_TVERTLIST", 14)) {
+                ParseLV3MeshTListBlock(iNumTVertices, mesh);
                 continue;
             }
             // mesh texture face block
-            if (TokenMatch(filePtr,"MESH_TFACELIST" ,14))
-            {
-                ParseLV3MeshTFaceListBlock(iNumTFaces,mesh);
+            if (TokenMatch(filePtr, "MESH_TFACELIST", 14)) {
+                ParseLV3MeshTFaceListBlock(iNumTFaces, mesh);
                 continue;
             }
             // mesh color vertex list block
-            if (TokenMatch(filePtr,"MESH_CVERTLIST" ,14))
-            {
-                ParseLV3MeshCListBlock(iNumCVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_CVERTLIST", 14)) {
+                ParseLV3MeshCListBlock(iNumCVertices, mesh);
                 continue;
             }
             // mesh color face block
-            if (TokenMatch(filePtr,"MESH_CFACELIST" ,14))
-            {
-                ParseLV3MeshCFaceListBlock(iNumCFaces,mesh);
+            if (TokenMatch(filePtr, "MESH_CFACELIST", 14)) {
+                ParseLV3MeshCFaceListBlock(iNumCFaces, mesh);
                 continue;
             }
             // mesh normals
-            if (TokenMatch(filePtr,"MESH_NORMALS" ,12))
-            {
+            if (TokenMatch(filePtr, "MESH_NORMALS", 12)) {
                 ParseLV3MeshNormalListBlock(mesh);
                 continue;
             }
             // another mesh UV channel ...
-            if (TokenMatch(filePtr,"MESH_MAPPINGCHANNEL" ,19)) {
-                unsigned int iIndex( 0 );
+            if (TokenMatch(filePtr, "MESH_MAPPINGCHANNEL", 19)) {
+                unsigned int iIndex(0);
                 ParseLV4MeshLong(iIndex);
-                if ( 0 == iIndex ) {
-                    LogWarning( "Mapping channel has an invalid index. Skipping UV channel" );
+                if (0 == iIndex) {
+                    LogWarning("Mapping channel has an invalid index. Skipping UV channel");
                     // skip it ...
                     SkipSection();
                 } else {
-                    if ( iIndex < 2 ) {
-                        LogWarning( "Mapping channel has an invalid index. Skipping UV channel" );
+                    if (iIndex < 2) {
+                        LogWarning("Mapping channel has an invalid index. Skipping UV channel");
                         // skip it ...
                         SkipSection();
                     }
-                    if ( iIndex > AI_MAX_NUMBER_OF_TEXTURECOORDS ) {
-                        LogWarning( "Too many UV channels specified. Skipping channel .." );
+                    if (iIndex > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
+                        LogWarning("Too many UV channels specified. Skipping channel ..");
                         // skip it ...
                         SkipSection();
                     } else {
                         // parse the mapping channel
-                        ParseLV3MappingChannel( iIndex - 1, mesh );
+                        ParseLV3MappingChannel(iIndex - 1, mesh);
                     }
                     continue;
                 }
             }
             // mesh animation keyframe. Not supported
-            if (TokenMatch(filePtr,"MESH_ANIMATION" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_ANIMATION", 14)) {
 
                 LogWarning("Found *MESH_ANIMATION element in ASE/ASK file. "
-                    "Keyframe animation is not supported by Assimp, this element "
-                    "will be ignored");
+                           "Keyframe animation is not supported by Assimp, this element "
+                           "will be ignored");
                 //SkipSection();
                 continue;
             }
-            if (TokenMatch(filePtr,"MESH_WEIGHTS" ,12))
-            {
-                ParseLV3MeshWeightsBlock(mesh);continue;
+            if (TokenMatch(filePtr, "MESH_WEIGHTS", 12)) {
+                ParseLV3MeshWeightsBlock(mesh);
+                continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("2","*MESH");
+        AI_ASE_HANDLE_SECTION("2", "*MESH");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshWeightsBlock(ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshWeightsBlock(ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumVertices = 0, iNumBones = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Number of bone vertices ...
-            if (TokenMatch(filePtr,"MESH_NUMVERTEX" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMVERTEX", 14)) {
                 ParseLV4MeshLong(iNumVertices);
                 continue;
             }
             // Number of bones
-            if (TokenMatch(filePtr,"MESH_NUMBONE" ,12))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMBONE", 12)) {
                 ParseLV4MeshLong(iNumBones);
                 continue;
             }
             // parse the list of bones
-            if (TokenMatch(filePtr,"MESH_BONE_LIST" ,14))
-            {
-                ParseLV4MeshBones(iNumBones,mesh);
+            if (TokenMatch(filePtr, "MESH_BONE_LIST", 14)) {
+                ParseLV4MeshBones(iNumBones, mesh);
                 continue;
             }
             // parse the list of bones vertices
-            if (TokenMatch(filePtr,"MESH_BONE_VERTEX_LIST" ,21) )
-            {
-                ParseLV4MeshBonesVertices(iNumVertices,mesh);
+            if (TokenMatch(filePtr, "MESH_BONE_VERTEX_LIST", 21)) {
+                ParseLV4MeshBonesVertices(iNumVertices, mesh);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_WEIGHTS");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_WEIGHTS");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshBones(unsigned int iNumBones,ASE::Mesh& mesh)
-{
+void Parser::ParseLV4MeshBones(unsigned int iNumBones, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
     mesh.mBones.resize(iNumBones, Bone("UNNAMED"));
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Mesh bone with name ...
-            if (TokenMatch(filePtr,"MESH_BONE_NAME" ,14))
-            {
+            if (TokenMatch(filePtr, "MESH_BONE_NAME", 14)) {
                 // parse an index ...
-                if(SkipSpaces(&filePtr))
-                {
-                    unsigned int iIndex = strtoul10(filePtr,&filePtr);
-                    if (iIndex >= iNumBones)
-                    {
+                if (SkipSpaces(&filePtr)) {
+                    unsigned int iIndex = strtoul10(filePtr, &filePtr);
+                    if (iIndex >= iNumBones) {
                         LogWarning("Bone index is out of bounds");
                         continue;
                     }
-                    if (!ParseString(mesh.mBones[iIndex].mName,"*MESH_BONE_NAME"))
+                    if (!ParseString(mesh.mBones[iIndex].mName, "*MESH_BONE_NAME"))
                         SkipToNextToken();
                     continue;
                 }
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_BONE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_BONE_LIST");
     }
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshBonesVertices(unsigned int iNumVertices,ASE::Mesh& mesh)
-{
+void Parser::ParseLV4MeshBonesVertices(unsigned int iNumVertices, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
     mesh.mBoneVertices.resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Mesh bone vertex
-            if (TokenMatch(filePtr,"MESH_BONE_VERTEX" ,16))
-            {
+            if (TokenMatch(filePtr, "MESH_BONE_VERTEX", 16)) {
                 // read the vertex index
-                unsigned int iIndex = strtoul10(filePtr,&filePtr);
-                if (iIndex >= mesh.mPositions.size())
-                {
-                    iIndex = (unsigned int)mesh.mPositions.size()-1;
+                unsigned int iIndex = strtoul10(filePtr, &filePtr);
+                if (iIndex >= mesh.mPositions.size()) {
+                    iIndex = (unsigned int)mesh.mPositions.size() - 1;
                     LogWarning("Bone vertex index is out of bounds. Using the largest valid "
-                        "bone vertex index instead");
+                               "bone vertex index instead");
                 }
 
                 // --- ignored
                 ai_real afVert[3];
                 ParseLV4MeshFloatTriple(afVert);
 
-                std::pair<int,float> pairOut;
-                while (true)
-                {
+                std::pair<int, float> pairOut;
+                while (true) {
                     // first parse the bone index ...
-                    if (!SkipSpaces(&filePtr))break;
-                    pairOut.first = strtoul10(filePtr,&filePtr);
+                    if (!SkipSpaces(&filePtr)) break;
+                    pairOut.first = strtoul10(filePtr, &filePtr);
 
                     // then parse the vertex weight
-                    if (!SkipSpaces(&filePtr))break;
-                    filePtr = fast_atoreal_move<float>(filePtr,pairOut.second);
+                    if (!SkipSpaces(&filePtr)) break;
+                    filePtr = fast_atoreal_move<float>(filePtr, pairOut.second);
 
                     // -1 marks unused entries
-                    if (-1 != pairOut.first)
-                    {
+                    if (-1 != pairOut.first) {
                         mesh.mBoneVertices[iIndex].mBoneWeights.push_back(pairOut);
                     }
                 }
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("4","*MESH_BONE_VERTEX");
+        AI_ASE_HANDLE_SECTION("4", "*MESH_BONE_VERTEX");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
 void Parser::ParseLV3MeshVertexListBlock(
-    unsigned int iNumVertices, ASE::Mesh& mesh)
-{
+        unsigned int iNumVertices, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the array
     mesh.mPositions.resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Vertex entry
-            if (TokenMatch(filePtr,"MESH_VERTEX" ,11))
-            {
+            if (TokenMatch(filePtr, "MESH_VERTEX", 11)) {
 
                 aiVector3D vTemp;
                 unsigned int iIndex;
-                ParseLV4MeshFloatTriple(&vTemp.x,iIndex);
+                ParseLV4MeshFloatTriple(&vTemp.x, iIndex);
 
-                if (iIndex >= iNumVertices)
-                {
+                if (iIndex >= iNumVertices) {
                     LogWarning("Invalid vertex index. It will be ignored");
-                }
-                else mesh.mPositions[iIndex] = vTemp;
+                } else
+                    mesh.mPositions[iIndex] = vTemp;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_VERTEX_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_VERTEX_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the face array
     mesh.mFaces.resize(iNumFaces);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_FACE" ,9))
-            {
+            if (TokenMatch(filePtr, "MESH_FACE", 9)) {
 
                 ASE::Face mFace;
                 ParseLV4MeshFace(mFace);
 
-                if (mFace.iFace >= iNumFaces)
-                {
+                if (mFace.iFace >= iNumFaces) {
                     LogWarning("Face has an invalid index. It will be ignored");
-                }
-                else mesh.mFaces[mFace.iFace] = mFace;
+                } else
+                    mesh.mFaces[mFace.iFace] = mFace;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_FACE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_FACE_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
 void Parser::ParseLV3MeshTListBlock(unsigned int iNumVertices,
-    ASE::Mesh& mesh, unsigned int iChannel)
-{
+        ASE::Mesh &mesh, unsigned int iChannel) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the array
     mesh.amTexCoords[iChannel].resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Vertex entry
-            if (TokenMatch(filePtr,"MESH_TVERT" ,10))
-            {
+            if (TokenMatch(filePtr, "MESH_TVERT", 10)) {
                 aiVector3D vTemp;
                 unsigned int iIndex;
-                ParseLV4MeshFloatTriple(&vTemp.x,iIndex);
+                ParseLV4MeshFloatTriple(&vTemp.x, iIndex);
 
-                if (iIndex >= iNumVertices)
-                {
+                if (iIndex >= iNumVertices) {
                     LogWarning("Tvertex has an invalid index. It will be ignored");
-                }
-                else mesh.amTexCoords[iChannel][iIndex] = vTemp;
+                } else
+                    mesh.amTexCoords[iChannel][iIndex] = vTemp;
 
-                if (0.0f != vTemp.z)
-                {
+                if (0.0f != vTemp.z) {
                     // we need 3 coordinate channels
                     mesh.mNumUVComponents[iChannel] = 3;
                 }
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_TVERT_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_TVERT_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
 void Parser::ParseLV3MeshTFaceListBlock(unsigned int iNumFaces,
-    ASE::Mesh& mesh, unsigned int iChannel)
-{
+        ASE::Mesh &mesh, unsigned int iChannel) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_TFACE" ,10))
-            {
+            if (TokenMatch(filePtr, "MESH_TFACE", 10)) {
                 unsigned int aiValues[3];
                 unsigned int iIndex = 0;
 
-                ParseLV4MeshLongTriple(aiValues,iIndex);
-                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size())
-                {
+                ParseLV4MeshLongTriple(aiValues, iIndex);
+                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) {
                     LogWarning("UV-Face has an invalid index. It will be ignored");
-                }
-                else
-                {
+                } else {
                     // copy UV indices
                     mesh.mFaces[iIndex].amUVIndices[iChannel][0] = aiValues[0];
                     mesh.mFaces[iIndex].amUVIndices[iChannel][1] = aiValues[1];
@@ -1771,108 +1520,89 @@ void Parser::ParseLV3MeshTFaceListBlock(unsigned int iNumFaces,
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_TFACE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_TFACE_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MappingChannel(unsigned int iChannel, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MappingChannel(unsigned int iChannel, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     unsigned int iNumTVertices = 0;
     unsigned int iNumTFaces = 0;
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Number of texture coordinates in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVERTEX" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVERTEX", 15)) {
                 ParseLV4MeshLong(iNumTVertices);
                 continue;
             }
             // Number of UVWed faces in the mesh
-            if (TokenMatch(filePtr,"MESH_NUMTVFACES" ,15))
-            {
+            if (TokenMatch(filePtr, "MESH_NUMTVFACES", 15)) {
                 ParseLV4MeshLong(iNumTFaces);
                 continue;
             }
             // mesh texture vertex list block
-            if (TokenMatch(filePtr,"MESH_TVERTLIST" ,14))
-            {
-                ParseLV3MeshTListBlock(iNumTVertices,mesh,iChannel);
+            if (TokenMatch(filePtr, "MESH_TVERTLIST", 14)) {
+                ParseLV3MeshTListBlock(iNumTVertices, mesh, iChannel);
                 continue;
             }
             // mesh texture face block
-            if (TokenMatch(filePtr,"MESH_TFACELIST" ,14))
-            {
-                ParseLV3MeshTFaceListBlock(iNumTFaces,mesh, iChannel);
+            if (TokenMatch(filePtr, "MESH_TFACELIST", 14)) {
+                ParseLV3MeshTFaceListBlock(iNumTFaces, mesh, iChannel);
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_MAPPING_CHANNEL");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_MAPPING_CHANNEL");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshCListBlock(unsigned int iNumVertices, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshCListBlock(unsigned int iNumVertices, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
 
     // allocate enough storage in the array
     mesh.mVertexColors.resize(iNumVertices);
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Vertex entry
-            if (TokenMatch(filePtr,"MESH_VERTCOL" ,12))
-            {
+            if (TokenMatch(filePtr, "MESH_VERTCOL", 12)) {
                 aiColor4D vTemp;
                 vTemp.a = 1.0f;
                 unsigned int iIndex;
-                ParseLV4MeshFloatTriple(&vTemp.r,iIndex);
+                ParseLV4MeshFloatTriple(&vTemp.r, iIndex);
 
-                if (iIndex >= iNumVertices)
-                {
+                if (iIndex >= iNumVertices) {
                     LogWarning("Vertex color has an invalid index. It will be ignored");
-                }
-                else mesh.mVertexColors[iIndex] = vTemp;
+                } else
+                    mesh.mVertexColors[iIndex] = vTemp;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_CVERTEX_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_CVERTEX_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
-{
+void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh &mesh) {
     AI_ASE_PARSER_INIT();
-    while (true)
-    {
-        if ('*' == *filePtr)
-        {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_CFACE" ,10))
-            {
+            if (TokenMatch(filePtr, "MESH_CFACE", 10)) {
                 unsigned int aiValues[3];
                 unsigned int iIndex = 0;
 
-                ParseLV4MeshLongTriple(aiValues,iIndex);
-                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size())
-                {
+                ParseLV4MeshLongTriple(aiValues, iIndex);
+                if (iIndex >= iNumFaces || iIndex >= mesh.mFaces.size()) {
                     LogWarning("UV-Face has an invalid index. It will be ignored");
-                }
-                else
-                {
+                } else {
                     // copy color indices
                     mesh.mFaces[iIndex].mColorIndices[0] = aiValues[0];
                     mesh.mFaces[iIndex].mColorIndices[1] = aiValues[1];
@@ -1881,17 +1611,16 @@ void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_CFACE_LIST");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_CFACE_LIST");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
-{
+void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh &sMesh) {
     AI_ASE_PARSER_INIT();
 
     // Allocate enough storage for the normals
-    sMesh.mNormals.resize(sMesh.mFaces.size()*3,aiVector3D( 0.f, 0.f, 0.f ));
+    sMesh.mNormals.resize(sMesh.mFaces.size() * 3, aiVector3D(0.f, 0.f, 0.f));
     unsigned int index, faceIdx = UINT_MAX;
 
     // FIXME: rewrite this and find out how to interpret the normals
@@ -1899,34 +1628,34 @@ void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
 
     // Smooth the vertex and face normals together. The result
     // will be edgy then, but otherwise everything would be soft ...
-    while (true)    {
-        if ('*' == *filePtr)    {
+    while (true) {
+        if ('*' == *filePtr) {
             ++filePtr;
-            if (faceIdx != UINT_MAX && TokenMatch(filePtr,"MESH_VERTEXNORMAL",17))  {
+            if (faceIdx != UINT_MAX && TokenMatch(filePtr, "MESH_VERTEXNORMAL", 17)) {
                 aiVector3D vNormal;
-                ParseLV4MeshFloatTriple(&vNormal.x,index);
-                if (faceIdx >=  sMesh.mFaces.size())
+                ParseLV4MeshFloatTriple(&vNormal.x, index);
+                if (faceIdx >= sMesh.mFaces.size())
                     continue;
 
                 // Make sure we assign it to the correct face
-                const ASE::Face& face = sMesh.mFaces[faceIdx];
+                const ASE::Face &face = sMesh.mFaces[faceIdx];
                 if (index == face.mIndices[0])
                     index = 0;
                 else if (index == face.mIndices[1])
                     index = 1;
                 else if (index == face.mIndices[2])
                     index = 2;
-                else    {
+                else {
                     ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_VERTEXNORMAL section");
                     continue;
                 }
                 // We'll renormalize later
-                sMesh.mNormals[faceIdx*3+index] += vNormal;
+                sMesh.mNormals[faceIdx * 3 + index] += vNormal;
                 continue;
             }
-            if (TokenMatch(filePtr,"MESH_FACENORMAL",15))   {
+            if (TokenMatch(filePtr, "MESH_FACENORMAL", 15)) {
                 aiVector3D vNormal;
-                ParseLV4MeshFloatTriple(&vNormal.x,faceIdx);
+                ParseLV4MeshFloatTriple(&vNormal.x, faceIdx);
 
                 if (faceIdx >= sMesh.mFaces.size()) {
                     ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_FACENORMAL section");
@@ -1934,53 +1663,47 @@ void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
                 }
 
                 // We'll renormalize later
-                sMesh.mNormals[faceIdx*3] += vNormal;
-                sMesh.mNormals[faceIdx*3+1] += vNormal;
-                sMesh.mNormals[faceIdx*3+2] += vNormal;
+                sMesh.mNormals[faceIdx * 3] += vNormal;
+                sMesh.mNormals[faceIdx * 3 + 1] += vNormal;
+                sMesh.mNormals[faceIdx * 3 + 2] += vNormal;
                 continue;
             }
         }
-        AI_ASE_HANDLE_SECTION("3","*MESH_NORMALS");
+        AI_ASE_HANDLE_SECTION("3", "*MESH_NORMALS");
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFace(ASE::Face& out)
-{
+void Parser::ParseLV4MeshFace(ASE::Face &out) {
     // skip spaces and tabs
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL [#1]");
         SkipToNextToken();
         return;
     }
 
     // parse the face index
-    out.iFace = strtoul10(filePtr,&filePtr);
+    out.iFace = strtoul10(filePtr, &filePtr);
 
     // next character should be ':'
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         // FIX: there are some ASE files which haven't got : here ....
         LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. \':\' expected [#2]");
         SkipToNextToken();
         return;
     }
     // FIX: There are some ASE files which haven't got ':' here
-    if(':' == *filePtr)++filePtr;
+    if (':' == *filePtr) ++filePtr;
 
     // Parse all mesh indices
-    for (unsigned int i = 0; i < 3;++i)
-    {
+    for (unsigned int i = 0; i < 3; ++i) {
         unsigned int iIndex = 0;
-        if(!SkipSpaces(&filePtr))
-        {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL");
             SkipToNextToken();
             return;
         }
-        switch (*filePtr)
-        {
+        switch (*filePtr) {
         case 'A':
         case 'a':
             break;
@@ -1994,38 +1717,34 @@ void Parser::ParseLV4MeshFace(ASE::Face& out)
             break;
         default:
             LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. "
-                "A,B or C expected [#3]");
+                       "A,B or C expected [#3]");
             SkipToNextToken();
             return;
         };
         ++filePtr;
 
         // next character should be ':'
-        if(!SkipSpaces(&filePtr) || ':' != *filePtr)
-        {
+        if (!SkipSpaces(&filePtr) || ':' != *filePtr) {
             LogWarning("Unable to parse *MESH_FACE Element: "
-                "Unexpected EOL. \':\' expected [#2]");
+                       "Unexpected EOL. \':\' expected [#2]");
             SkipToNextToken();
             return;
         }
 
         ++filePtr;
-        if(!SkipSpaces(&filePtr))
-        {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_FACE Element: Unexpected EOL. "
-                "Vertex index ecpected [#4]");
+                       "Vertex index ecpected [#4]");
             SkipToNextToken();
             return;
         }
-        out.mIndices[iIndex] = strtoul10(filePtr,&filePtr);
+        out.mIndices[iIndex] = strtoul10(filePtr, &filePtr);
     }
 
     // now we need to skip the AB, BC, CA blocks.
-    while (true)
-    {
-        if ('*' == *filePtr)break;
-        if (IsLineEnd(*filePtr))
-        {
+    while (true) {
+        if ('*' == *filePtr) break;
+        if (IsLineEnd(*filePtr)) {
             //iLineNumber++;
             return;
         }
@@ -2033,27 +1752,22 @@ void Parser::ParseLV4MeshFace(ASE::Face& out)
     }
 
     // parse the smoothing group of the face
-    if (TokenMatch(filePtr,"*MESH_SMOOTHING",15))
-    {
-        if(!SkipSpaces(&filePtr))
-        {
+    if (TokenMatch(filePtr, "*MESH_SMOOTHING", 15)) {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_SMOOTHING Element: "
-                "Unexpected EOL. Smoothing group(s) expected [#5]");
+                       "Unexpected EOL. Smoothing group(s) expected [#5]");
             SkipToNextToken();
             return;
         }
 
         // Parse smoothing groups until we don't anymore see commas
         // FIX: There needn't always be a value, sad but true
-        while (true)
-        {
-            if (*filePtr < '9' && *filePtr >= '0')
-            {
-                out.iSmoothGroup |= (1 << strtoul10(filePtr,&filePtr));
+        while (true) {
+            if (*filePtr < '9' && *filePtr >= '0') {
+                out.iSmoothGroup |= (1 << strtoul10(filePtr, &filePtr));
             }
             SkipSpaces(&filePtr);
-            if (',' != *filePtr)
-            {
+            if (',' != *filePtr) {
                 break;
             }
             ++filePtr;
@@ -2062,40 +1776,34 @@ void Parser::ParseLV4MeshFace(ASE::Face& out)
     }
 
     // *MESH_MTLID  is optional, too
-    while (true)
-    {
-        if ('*' == *filePtr)break;
-        if (IsLineEnd(*filePtr))
-        {
+    while (true) {
+        if ('*' == *filePtr) break;
+        if (IsLineEnd(*filePtr)) {
             return;
         }
         filePtr++;
     }
 
-    if (TokenMatch(filePtr,"*MESH_MTLID",11))
-    {
-        if(!SkipSpaces(&filePtr))
-        {
+    if (TokenMatch(filePtr, "*MESH_MTLID", 11)) {
+        if (!SkipSpaces(&filePtr)) {
             LogWarning("Unable to parse *MESH_MTLID Element: Unexpected EOL. "
-                "Material index expected [#6]");
+                       "Material index expected [#6]");
             SkipToNextToken();
             return;
         }
-        out.iMaterial = strtoul10(filePtr,&filePtr);
+        out.iMaterial = strtoul10(filePtr, &filePtr);
     }
     return;
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshLongTriple(unsigned int* apOut)
-{
+void Parser::ParseLV4MeshLongTriple(unsigned int *apOut) {
     ai_assert(NULL != apOut);
 
-    for (unsigned int i = 0; i < 3;++i)
+    for (unsigned int i = 0; i < 3; ++i)
         ParseLV4MeshLong(apOut[i]);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshLongTriple(unsigned int* apOut, unsigned int& rIndexOut)
-{
+void Parser::ParseLV4MeshLongTriple(unsigned int *apOut, unsigned int &rIndexOut) {
     ai_assert(NULL != apOut);
 
     // parse the index
@@ -2105,8 +1813,7 @@ void Parser::ParseLV4MeshLongTriple(unsigned int* apOut, unsigned int& rIndexOut
     ParseLV4MeshLongTriple(apOut);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut)
-{
+void Parser::ParseLV4MeshFloatTriple(ai_real *apOut, unsigned int &rIndexOut) {
     ai_assert(NULL != apOut);
 
     // parse the index
@@ -2116,19 +1823,16 @@ void Parser::ParseLV4MeshFloatTriple(ai_real* apOut, unsigned int& rIndexOut)
     ParseLV4MeshFloatTriple(apOut);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFloatTriple(ai_real* apOut)
-{
+void Parser::ParseLV4MeshFloatTriple(ai_real *apOut) {
     ai_assert(NULL != apOut);
 
-    for (unsigned int i = 0; i < 3;++i)
+    for (unsigned int i = 0; i < 3; ++i)
         ParseLV4MeshFloat(apOut[i]);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshFloat(ai_real& fOut)
-{
+void Parser::ParseLV4MeshFloat(ai_real &fOut) {
     // skip spaces and tabs
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         // LOG
         LogWarning("Unable to parse float: unexpected EOL [#1]");
         fOut = 0.0;
@@ -2136,14 +1840,12 @@ void Parser::ParseLV4MeshFloat(ai_real& fOut)
         return;
     }
     // parse the first float
-    filePtr = fast_atoreal_move<ai_real>(filePtr,fOut);
+    filePtr = fast_atoreal_move<ai_real>(filePtr, fOut);
 }
 // ------------------------------------------------------------------------------------------------
-void Parser::ParseLV4MeshLong(unsigned int& iOut)
-{
+void Parser::ParseLV4MeshLong(unsigned int &iOut) {
     // Skip spaces and tabs
-    if(!SkipSpaces(&filePtr))
-    {
+    if (!SkipSpaces(&filePtr)) {
         // LOG
         LogWarning("Unable to parse long: unexpected EOL [#1]");
         iOut = 0;
@@ -2151,7 +1853,7 @@ void Parser::ParseLV4MeshLong(unsigned int& iOut)
         return;
     }
     // parse the value
-    iOut = strtoul10(filePtr,&filePtr);
+    iOut = strtoul10(filePtr, &filePtr);
 }
 
 #endif // ASSIMP_BUILD_NO_3DS_IMPORTER
diff --git a/code/ASE/ASEParser.h b/code/AssetLib/ASE/ASEParser.h
similarity index 99%
rename from code/ASE/ASEParser.h
rename to code/AssetLib/ASE/ASEParser.h
index aba37d38f..c94c8e3aa 100644
--- a/code/ASE/ASEParser.h
+++ b/code/AssetLib/ASE/ASEParser.h
@@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/qnan.h>
 
 // ASE is quite similar to 3ds. We can reuse some structures
-#include "3DS/3DSLoader.h"
+#include "AssetLib/3DS/3DSLoader.h"
 
 namespace Assimp    {
 namespace ASE   {
diff --git a/code/Assbin/AssbinExporter.cpp b/code/AssetLib/Assbin/AssbinExporter.cpp
similarity index 99%
rename from code/Assbin/AssbinExporter.cpp
rename to code/AssetLib/Assbin/AssbinExporter.cpp
index 0b99afbda..e86a6526d 100644
--- a/code/Assbin/AssbinExporter.cpp
+++ b/code/AssetLib/Assbin/AssbinExporter.cpp
@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/code/Assbin/AssbinExporter.h b/code/AssetLib/Assbin/AssbinExporter.h
similarity index 100%
rename from code/Assbin/AssbinExporter.h
rename to code/AssetLib/Assbin/AssbinExporter.h
diff --git a/code/Assbin/AssbinFileWriter.cpp b/code/AssetLib/Assbin/AssbinFileWriter.cpp
similarity index 96%
rename from code/Assbin/AssbinFileWriter.cpp
rename to code/AssetLib/Assbin/AssbinFileWriter.cpp
index 7fceaa1ad..431be4d3a 100644
--- a/code/Assbin/AssbinFileWriter.cpp
+++ b/code/AssetLib/Assbin/AssbinFileWriter.cpp
@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -54,16 +53,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOStream.hpp>
 
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#    include <zlib.h>
+#include <zlib.h>
 #else
-#    include "../contrib/zlib/zlib.h"
+#include "../contrib/zlib/zlib.h"
 #endif
 
 #include <time.h>
 
 #ifdef _WIN32
-#    pragma warning(push)
-#    pragma warning(disable : 4706)
+#pragma warning(push)
+#pragma warning(disable : 4706)
 #endif // _WIN32
 
 namespace Assimp {
@@ -269,7 +268,7 @@ private:
 
 public:
     AssbinChunkWriter(IOStream *container, uint32_t magic, size_t initial = 4096) :
-            buffer(NULL),
+            buffer(nullptr),
             magic(magic),
             container(container),
             cur_size(0),
@@ -362,32 +361,32 @@ protected:
             Write<uint16_t>(&chunk, (uint16_t)type);
 
             switch (type) {
-                case AI_BOOL:
-                    Write<bool>(&chunk, *((bool *)value));
-                    break;
-                case AI_INT32:
-                    Write<int32_t>(&chunk, *((int32_t *)value));
-                    break;
-                case AI_UINT64:
-                    Write<uint64_t>(&chunk, *((uint64_t *)value));
-                    break;
-                case AI_FLOAT:
-                    Write<float>(&chunk, *((float *)value));
-                    break;
-                case AI_DOUBLE:
-                    Write<double>(&chunk, *((double *)value));
-                    break;
-                case AI_AISTRING:
-                    Write<aiString>(&chunk, *((aiString *)value));
-                    break;
-                case AI_AIVECTOR3D:
-                    Write<aiVector3D>(&chunk, *((aiVector3D *)value));
-                    break;
+            case AI_BOOL:
+                Write<bool>(&chunk, *((bool *)value));
+                break;
+            case AI_INT32:
+                Write<int32_t>(&chunk, *((int32_t *)value));
+                break;
+            case AI_UINT64:
+                Write<uint64_t>(&chunk, *((uint64_t *)value));
+                break;
+            case AI_FLOAT:
+                Write<float>(&chunk, *((float *)value));
+                break;
+            case AI_DOUBLE:
+                Write<double>(&chunk, *((double *)value));
+                break;
+            case AI_AISTRING:
+                Write<aiString>(&chunk, *((aiString *)value));
+                break;
+            case AI_AIVECTOR3D:
+                Write<aiVector3D>(&chunk, *((aiVector3D *)value));
+                break;
 #ifdef SWIG
                 case FORCE_32BIT:
 #endif // SWIG
-                default:
-                    break;
+            default:
+                break;
             }
         }
     }
@@ -827,7 +826,7 @@ void DumpSceneToAssbin(
     fileWriter.WriteBinaryDump(pFile, cmd, pIOSystem, pScene);
 }
 #ifdef _WIN32
-#    pragma warning(pop)
+#pragma warning(pop)
 #endif // _WIN32
 
 } // end of namespace Assimp
diff --git a/code/Assbin/AssbinFileWriter.h b/code/AssetLib/Assbin/AssbinFileWriter.h
similarity index 92%
rename from code/Assbin/AssbinFileWriter.h
rename to code/AssetLib/Assbin/AssbinFileWriter.h
index 25db6db2d..25cbc8106 100644
--- a/code/Assbin/AssbinFileWriter.h
+++ b/code/AssetLib/Assbin/AssbinFileWriter.h
@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -54,12 +53,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 void ASSIMP_API DumpSceneToAssbin(
-    const char* pFile,
-    const char* cmd,
-    IOSystem* pIOSystem,
-    const aiScene* pScene,
-    bool shortened,
-    bool compressed);
+        const char *pFile,
+        const char *cmd,
+        IOSystem *pIOSystem,
+        const aiScene *pScene,
+        bool shortened,
+        bool compressed);
 
 }
 
diff --git a/code/Assbin/AssbinLoader.cpp b/code/AssetLib/Assbin/AssbinLoader.cpp
similarity index 96%
rename from code/Assbin/AssbinLoader.cpp
rename to code/AssetLib/Assbin/AssbinLoader.cpp
index 4293cae29..5ee87e952 100644
--- a/code/Assbin/AssbinLoader.cpp
+++ b/code/AssetLib/Assbin/AssbinLoader.cpp
@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
 
 // internal headers
-#include "Assbin/AssbinLoader.h"
+#include "AssetLib/Assbin/AssbinLoader.h"
 #include "Common/assbin_chunks.h"
 #include <assimp/MemoryIOWrapper.h>
 #include <assimp/anim.h>
@@ -253,32 +253,32 @@ void AssbinImporter::ReadBinaryNode(IOStream *stream, aiNode **onode, aiNode *pa
             void *data = nullptr;
 
             switch (node->mMetaData->mValues[i].mType) {
-                case AI_BOOL:
-                    data = new bool(Read<bool>(stream));
-                    break;
-                case AI_INT32:
-                    data = new int32_t(Read<int32_t>(stream));
-                    break;
-                case AI_UINT64:
-                    data = new uint64_t(Read<uint64_t>(stream));
-                    break;
-                case AI_FLOAT:
-                    data = new ai_real(Read<ai_real>(stream));
-                    break;
-                case AI_DOUBLE:
-                    data = new double(Read<double>(stream));
-                    break;
-                case AI_AISTRING:
-                    data = new aiString(Read<aiString>(stream));
-                    break;
-                case AI_AIVECTOR3D:
-                    data = new aiVector3D(Read<aiVector3D>(stream));
-                    break;
+            case AI_BOOL:
+                data = new bool(Read<bool>(stream));
+                break;
+            case AI_INT32:
+                data = new int32_t(Read<int32_t>(stream));
+                break;
+            case AI_UINT64:
+                data = new uint64_t(Read<uint64_t>(stream));
+                break;
+            case AI_FLOAT:
+                data = new ai_real(Read<ai_real>(stream));
+                break;
+            case AI_DOUBLE:
+                data = new double(Read<double>(stream));
+                break;
+            case AI_AISTRING:
+                data = new aiString(Read<aiString>(stream));
+                break;
+            case AI_AIVECTOR3D:
+                data = new aiVector3D(Read<aiVector3D>(stream));
+                break;
 #ifndef SWIG
-                case FORCE_32BIT:
+            case FORCE_32BIT:
 #endif // SWIG
-                default:
-                    break;
+            default:
+                break;
             }
 
             node->mMetaData->mValues[i].mData = data;
diff --git a/code/Assbin/AssbinLoader.h b/code/AssetLib/Assbin/AssbinLoader.h
similarity index 100%
rename from code/Assbin/AssbinLoader.h
rename to code/AssetLib/Assbin/AssbinLoader.h
diff --git a/code/Assjson/cencode.c b/code/AssetLib/Assjson/cencode.c
similarity index 100%
rename from code/Assjson/cencode.c
rename to code/AssetLib/Assjson/cencode.c
diff --git a/code/Assjson/cencode.h b/code/AssetLib/Assjson/cencode.h
similarity index 100%
rename from code/Assjson/cencode.h
rename to code/AssetLib/Assjson/cencode.h
diff --git a/code/Assjson/json_exporter.cpp b/code/AssetLib/Assjson/json_exporter.cpp
similarity index 81%
rename from code/Assjson/json_exporter.cpp
rename to code/AssetLib/Assjson/json_exporter.cpp
index 4a8e4599e..b9099d392 100644
--- a/code/Assjson/json_exporter.cpp
+++ b/code/AssetLib/Assjson/json_exporter.cpp
@@ -9,30 +9,31 @@ Licensed under a 3-clause BSD license. See the LICENSE file for more information
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_ASSJSON_EXPORTER
 
-#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
 #include <assimp/Exporter.hpp>
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+#include <assimp/Exceptional.h>
 
-#include <sstream>
-#include <limits>
 #include <cassert>
+#include <limits>
 #include <memory>
+#include <sstream>
 
 #define CURRENT_FORMAT_VERSION 100
 
-// grab scoped_ptr from assimp to avoid a dependency on boost. 
+// grab scoped_ptr from assimp to avoid a dependency on boost.
 //#include <assimp/../../code/BoostWorkaround/boost/scoped_ptr.hpp>
 
 #include "mesh_splitter.h"
 
 extern "C" {
-    #include "cencode.h"
+#include "cencode.h"
 }
 namespace Assimp {
 
-void ExportAssimp2Json(const char*, Assimp::IOSystem*, const aiScene*, const Assimp::ExportProperties*);
+void ExportAssimp2Json(const char *, Assimp::IOSystem *, const aiScene *, const Assimp::ExportProperties *);
 
 // small utility class to simplify serializing the aiScene to Json
 class JSONWriter {
@@ -42,10 +43,8 @@ public:
         Flag_WriteSpecialFloats = 0x2,
     };
 
-    JSONWriter(Assimp::IOStream& out, unsigned int flags = 0u)
-    : out(out)
-    , first()
-    , flags(flags) {
+    JSONWriter(Assimp::IOStream &out, unsigned int flags = 0u) :
+            out(out), first(), flags(flags) {
         // make sure that all formatting happens using the standard, C locale and not the user's current locale
         buff.imbue(std::locale("C"));
     }
@@ -68,30 +67,30 @@ public:
         indent.erase(indent.end() - 1);
     }
 
-    void Key(const std::string& name) {
+    void Key(const std::string &name) {
         AddIndentation();
         Delimit();
         buff << '\"' + name + "\": ";
     }
 
-    template<typename Literal>
-    void Element(const Literal& name) {
+    template <typename Literal>
+    void Element(const Literal &name) {
         AddIndentation();
         Delimit();
 
         LiteralToString(buff, name) << '\n';
     }
 
-    template<typename Literal>
-    void SimpleValue(const Literal& s) {
+    template <typename Literal>
+    void SimpleValue(const Literal &s) {
         LiteralToString(buff, s) << '\n';
     }
 
-    void SimpleValue(const void* buffer, size_t len) {
+    void SimpleValue(const void *buffer, size_t len) {
         base64_encodestate s;
         base64_init_encodestate(&s);
 
-        char* const cur_out = new char[std::max(len * 2, static_cast<size_t>(16u))];
+        char *const cur_out = new char[std::max(len * 2, static_cast<size_t>(16u))];
         const int n = base64_encode_block(reinterpret_cast<const char *>(buffer), static_cast<int>(len), cur_out, &s);
         cur_out[n + base64_encode_blockend(cur_out + n, &s)] = '\0';
 
@@ -156,21 +155,20 @@ public:
     void Delimit() {
         if (!first) {
             buff << ',';
-        }
-        else {
+        } else {
             buff << ' ';
             first = false;
         }
     }
 
 private:
-    template<typename Literal>
-    std::stringstream& LiteralToString(std::stringstream& stream, const Literal& s) {
+    template <typename Literal>
+    std::stringstream &LiteralToString(std::stringstream &stream, const Literal &s) {
         stream << s;
         return stream;
     }
 
-    std::stringstream& LiteralToString(std::stringstream& stream, const aiString& s) {
+    std::stringstream &LiteralToString(std::stringstream &stream, const aiString &s) {
         std::string t;
 
         // escape backslashes and single quotes, both would render the JSON invalid if left as is
@@ -189,10 +187,10 @@ private:
         return stream;
     }
 
-    std::stringstream& LiteralToString(std::stringstream& stream, float f) {
+    std::stringstream &LiteralToString(std::stringstream &stream, float f) {
         if (!std::numeric_limits<float>::is_iec559) {
             // on a non IEEE-754 platform, we make no assumptions about the representation or existence
-            // of special floating-point numbers. 
+            // of special floating-point numbers.
             stream << f;
             return stream;
         }
@@ -228,7 +226,7 @@ private:
     }
 
 private:
-    Assimp::IOStream& out;
+    Assimp::IOStream &out;
     std::string indent, newline;
     std::stringstream buff;
     bool first;
@@ -236,7 +234,7 @@ private:
     unsigned int flags;
 };
 
-void Write(JSONWriter& out, const aiVector3D& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiVector3D &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.x);
     out.Element(ai.y);
@@ -244,7 +242,7 @@ void Write(JSONWriter& out, const aiVector3D& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiQuaternion& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiQuaternion &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.w);
     out.Element(ai.x);
@@ -253,7 +251,7 @@ void Write(JSONWriter& out, const aiQuaternion& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiColor3D& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiColor3D &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     out.Element(ai.r);
     out.Element(ai.g);
@@ -261,7 +259,7 @@ void Write(JSONWriter& out, const aiColor3D& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiMatrix4x4& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiMatrix4x4 &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     for (unsigned int x = 0; x < 4; ++x) {
         for (unsigned int y = 0; y < 4; ++y) {
@@ -271,7 +269,7 @@ void Write(JSONWriter& out, const aiMatrix4x4& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiBone& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiBone &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -292,7 +290,7 @@ void Write(JSONWriter& out, const aiBone& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiFace& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiFace &ai, bool is_elem = true) {
     out.StartArray(is_elem);
     for (unsigned int i = 0; i < ai.mNumIndices; ++i) {
         out.Element(ai.mIndices[i]);
@@ -300,7 +298,7 @@ void Write(JSONWriter& out, const aiFace& ai, bool is_elem = true) {
     out.EndArray();
 }
 
-void Write(JSONWriter& out, const aiMesh& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiMesh &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -411,7 +409,7 @@ void Write(JSONWriter& out, const aiMesh& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiNode& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiNode &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -441,13 +439,13 @@ void Write(JSONWriter& out, const aiNode& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiMaterial &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("properties");
     out.StartArray();
     for (unsigned int i = 0; i < ai.mNumProperties; ++i) {
-        const aiMaterialProperty* const prop = ai.mProperties[i];
+        const aiMaterialProperty *const prop = ai.mProperties[i];
         out.StartObj(true);
         out.Key("key");
         out.SimpleValue(prop->mKey);
@@ -461,46 +459,41 @@ void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) {
 
         out.Key("value");
         switch (prop->mType) {
-            case aiPTI_Float:
-                if (prop->mDataLength / sizeof(float) > 1) {
-                    out.StartArray();
-                    for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(float); ++ii) {
-                        out.Element(reinterpret_cast<float*>(prop->mData)[ii]);
-                    }
-                    out.EndArray();
+        case aiPTI_Float:
+            if (prop->mDataLength / sizeof(float) > 1) {
+                out.StartArray();
+                for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(float); ++ii) {
+                    out.Element(reinterpret_cast<float *>(prop->mData)[ii]);
                 }
-                else {
-                    out.SimpleValue(*reinterpret_cast<float*>(prop->mData));
-                }
-                break;
+                out.EndArray();
+            } else {
+                out.SimpleValue(*reinterpret_cast<float *>(prop->mData));
+            }
+            break;
 
-            case aiPTI_Integer:
-                if (prop->mDataLength / sizeof(int) > 1) {
-                    out.StartArray();
-                    for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(int); ++ii) {
-                        out.Element(reinterpret_cast<int*>(prop->mData)[ii]);
-                    }
-                    out.EndArray();
-                } else {
-                    out.SimpleValue(*reinterpret_cast<int*>(prop->mData));
+        case aiPTI_Integer:
+            if (prop->mDataLength / sizeof(int) > 1) {
+                out.StartArray();
+                for (unsigned int ii = 0; ii < prop->mDataLength / sizeof(int); ++ii) {
+                    out.Element(reinterpret_cast<int *>(prop->mData)[ii]);
                 }
-                break;
+                out.EndArray();
+            } else {
+                out.SimpleValue(*reinterpret_cast<int *>(prop->mData));
+            }
+            break;
 
-            case aiPTI_String:
-                {
-                    aiString s;
-                    aiGetMaterialString(&ai, prop->mKey.data, prop->mSemantic, prop->mIndex, &s);
-                    out.SimpleValue(s);
-                }
-                break;
-            case aiPTI_Buffer:
-                {
-                    // binary data is written as series of hex-encoded octets
-                    out.SimpleValue(prop->mData, prop->mDataLength);
-                }
-                break;
-            default:
-                assert(false);
+        case aiPTI_String: {
+            aiString s;
+            aiGetMaterialString(&ai, prop->mKey.data, prop->mSemantic, prop->mIndex, &s);
+            out.SimpleValue(s);
+        } break;
+        case aiPTI_Buffer: {
+            // binary data is written as series of hex-encoded octets
+            out.SimpleValue(prop->mData, prop->mDataLength);
+        } break;
+        default:
+            assert(false);
         }
 
         out.EndObj();
@@ -510,7 +503,7 @@ void Write(JSONWriter& out, const aiMaterial& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiTexture &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("width");
@@ -525,13 +518,12 @@ void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) {
     out.Key("data");
     if (!ai.mHeight) {
         out.SimpleValue(ai.pcData, ai.mWidth);
-    }
-    else {
+    } else {
         out.StartArray();
         for (unsigned int y = 0; y < ai.mHeight; ++y) {
             out.StartArray(true);
             for (unsigned int x = 0; x < ai.mWidth; ++x) {
-                const aiTexel& tx = ai.pcData[y*ai.mWidth + x];
+                const aiTexel &tx = ai.pcData[y * ai.mWidth + x];
                 out.StartArray(true);
                 out.Element(static_cast<unsigned int>(tx.r));
                 out.Element(static_cast<unsigned int>(tx.g));
@@ -547,7 +539,7 @@ void Write(JSONWriter& out, const aiTexture& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiLight &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -585,7 +577,6 @@ void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) {
     if (ai.mType != aiLightSource_POINT) {
         out.Key("direction");
         Write(out, ai.mDirection, false);
-
     }
 
     if (ai.mType != aiLightSource_DIRECTIONAL) {
@@ -596,7 +587,7 @@ void Write(JSONWriter& out, const aiLight& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiNodeAnim &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -612,7 +603,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
         out.Key("positionkeys");
         out.StartArray();
         for (unsigned int n = 0; n < ai.mNumPositionKeys; ++n) {
-            const aiVectorKey& pos = ai.mPositionKeys[n];
+            const aiVectorKey &pos = ai.mPositionKeys[n];
             out.StartArray(true);
             out.Element(pos.mTime);
             Write(out, pos.mValue);
@@ -625,7 +616,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
         out.Key("rotationkeys");
         out.StartArray();
         for (unsigned int n = 0; n < ai.mNumRotationKeys; ++n) {
-            const aiQuatKey& rot = ai.mRotationKeys[n];
+            const aiQuatKey &rot = ai.mRotationKeys[n];
             out.StartArray(true);
             out.Element(rot.mTime);
             Write(out, rot.mValue);
@@ -638,7 +629,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
         out.Key("scalingkeys");
         out.StartArray();
         for (unsigned int n = 0; n < ai.mNumScalingKeys; ++n) {
-            const aiVectorKey& scl = ai.mScalingKeys[n];
+            const aiVectorKey &scl = ai.mScalingKeys[n];
             out.StartArray(true);
             out.Element(scl.mTime);
             Write(out, scl.mValue);
@@ -649,7 +640,7 @@ void Write(JSONWriter& out, const aiNodeAnim& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiAnimation& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiAnimation &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -670,7 +661,7 @@ void Write(JSONWriter& out, const aiAnimation& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiCamera& ai, bool is_elem = true) {
+void Write(JSONWriter &out, const aiCamera &ai, bool is_elem = true) {
     out.StartObj(is_elem);
 
     out.Key("name");
@@ -697,7 +688,7 @@ void Write(JSONWriter& out, const aiCamera& ai, bool is_elem = true) {
     out.EndObj();
 }
 
-void WriteFormatInfo(JSONWriter& out) {
+void WriteFormatInfo(JSONWriter &out) {
     out.StartObj();
     out.Key("format");
     out.SimpleValue("\"assimp2json\"");
@@ -706,7 +697,7 @@ void WriteFormatInfo(JSONWriter& out) {
     out.EndObj();
 }
 
-void Write(JSONWriter& out, const aiScene& ai) {
+void Write(JSONWriter &out, const aiScene &ai) {
     out.StartObj();
 
     out.Key("__metadata__");
@@ -774,15 +765,14 @@ void Write(JSONWriter& out, const aiScene& ai) {
     out.EndObj();
 }
 
-
-void ExportAssimp2Json(const char* file, Assimp::IOSystem* io, const aiScene* scene, const Assimp::ExportProperties*) {
+void ExportAssimp2Json(const char *file, Assimp::IOSystem *io, const aiScene *scene, const Assimp::ExportProperties *) {
     std::unique_ptr<Assimp::IOStream> str(io->Open(file, "wt"));
     if (!str) {
-        //throw Assimp::DeadlyExportError("could not open output file");
+        throw DeadlyExportError("could not open output file");
     }
 
     // get a copy of the scene so we can modify it
-    aiScene* scenecopy_tmp;
+    aiScene *scenecopy_tmp;
     aiCopyScene(scene, &scenecopy_tmp);
 
     try {
@@ -795,15 +785,14 @@ void ExportAssimp2Json(const char* file, Assimp::IOSystem* io, const aiScene* sc
         JSONWriter s(*str, JSONWriter::Flag_WriteSpecialFloats);
         Write(s, *scenecopy_tmp);
 
-    }
-    catch (...) {
+    } catch (...) {
         aiFreeScene(scenecopy_tmp);
         throw;
     }
     aiFreeScene(scenecopy_tmp);
 }
 
-}
+} // namespace Assimp
 
 #endif // ASSIMP_BUILD_NO_ASSJSON_EXPORTER
 #endif // ASSIMP_BUILD_NO_EXPORT
diff --git a/code/Assjson/mesh_splitter.cpp b/code/AssetLib/Assjson/mesh_splitter.cpp
similarity index 100%
rename from code/Assjson/mesh_splitter.cpp
rename to code/AssetLib/Assjson/mesh_splitter.cpp
diff --git a/code/Assjson/mesh_splitter.h b/code/AssetLib/Assjson/mesh_splitter.h
similarity index 100%
rename from code/Assjson/mesh_splitter.h
rename to code/AssetLib/Assjson/mesh_splitter.h
diff --git a/code/Assxml/AssxmlExporter.cpp b/code/AssetLib/Assxml/AssxmlExporter.cpp
similarity index 100%
rename from code/Assxml/AssxmlExporter.cpp
rename to code/AssetLib/Assxml/AssxmlExporter.cpp
diff --git a/code/Assxml/AssxmlExporter.h b/code/AssetLib/Assxml/AssxmlExporter.h
similarity index 100%
rename from code/Assxml/AssxmlExporter.h
rename to code/AssetLib/Assxml/AssxmlExporter.h
diff --git a/code/AssetLib/Assxml/AssxmlFileWriter.cpp b/code/AssetLib/Assxml/AssxmlFileWriter.cpp
new file mode 100644
index 000000000..b175265b5
--- /dev/null
+++ b/code/AssetLib/Assxml/AssxmlFileWriter.cpp
@@ -0,0 +1,659 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 AssxmlFileWriter.cpp
+ *  @brief Implementation of Assxml file writer.
+ */
+
+#include "AssxmlFileWriter.h"
+
+#include "PostProcessing/ProcessHelper.h"
+
+#include <assimp/version.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOStream.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <stdarg.h>
+
+#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
+#include <zlib.h>
+#else
+#include <contrib/zlib/zlib.h>
+#endif
+
+#include <stdio.h>
+#include <time.h>
+#include <memory>
+
+using namespace Assimp;
+
+namespace Assimp {
+
+namespace AssxmlFileWriter {
+
+// -----------------------------------------------------------------------------------
+static int ioprintf(IOStream *io, const char *format, ...) {
+    using namespace std;
+    if (nullptr == io) {
+        return -1;
+    }
+
+    static const int Size = 4096;
+    char sz[Size];
+    ::memset(sz, '\0', Size);
+    va_list va;
+    va_start(va, format);
+    const unsigned int nSize = vsnprintf(sz, Size - 1, format, va);
+    ai_assert(nSize < Size);
+    va_end(va);
+
+    io->Write(sz, sizeof(char), nSize);
+
+    return nSize;
+}
+
+// -----------------------------------------------------------------------------------
+// Convert a name to standard XML format
+static void ConvertName(aiString &out, const aiString &in) {
+    out.length = 0;
+    for (unsigned int i = 0; i < in.length; ++i) {
+        switch (in.data[i]) {
+        case '<':
+            out.Append("&lt;");
+            break;
+        case '>':
+            out.Append("&gt;");
+            break;
+        case '&':
+            out.Append("&amp;");
+            break;
+        case '\"':
+            out.Append("&quot;");
+            break;
+        case '\'':
+            out.Append("&apos;");
+            break;
+        default:
+            out.data[out.length++] = in.data[i];
+        }
+    }
+    out.data[out.length] = 0;
+}
+
+// -----------------------------------------------------------------------------------
+// Write a single node as text dump
+static void WriteNode(const aiNode *node, IOStream *io, unsigned int depth) {
+    char prefix[512];
+    for (unsigned int i = 0; i < depth; ++i)
+        prefix[i] = '\t';
+    prefix[depth] = '\0';
+
+    const aiMatrix4x4 &m = node->mTransformation;
+
+    aiString name;
+    ConvertName(name, node->mName);
+    ioprintf(io, "%s<Node name=\"%s\"> \n"
+                 "%s\t<Matrix4> \n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                 "%s\t</Matrix4> \n",
+            prefix, name.data, prefix,
+            prefix, m.a1, m.a2, m.a3, m.a4,
+            prefix, m.b1, m.b2, m.b3, m.b4,
+            prefix, m.c1, m.c2, m.c3, m.c4,
+            prefix, m.d1, m.d2, m.d3, m.d4, prefix);
+
+    if (node->mNumMeshes) {
+        ioprintf(io, "%s\t<MeshRefs num=\"%u\">\n%s\t",
+                prefix, node->mNumMeshes, prefix);
+
+        for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
+            ioprintf(io, "%u ", node->mMeshes[i]);
+        }
+        ioprintf(io, "\n%s\t</MeshRefs>\n", prefix);
+    }
+
+    if (node->mNumChildren) {
+        ioprintf(io, "%s\t<NodeList num=\"%u\">\n",
+                prefix, node->mNumChildren);
+
+        for (unsigned int i = 0; i < node->mNumChildren; ++i) {
+            WriteNode(node->mChildren[i], io, depth + 2);
+        }
+        ioprintf(io, "%s\t</NodeList>\n", prefix);
+    }
+    ioprintf(io, "%s</Node>\n", prefix);
+}
+
+// -----------------------------------------------------------------------------------
+// Some chuncks of text will need to be encoded for XML
+// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
+static std::string encodeXML(const std::string &data) {
+    std::string buffer;
+    buffer.reserve(data.size());
+    for (size_t pos = 0; pos != data.size(); ++pos) {
+        switch (data[pos]) {
+        case '&': buffer.append("&amp;"); break;
+        case '\"': buffer.append("&quot;"); break;
+        case '\'': buffer.append("&apos;"); break;
+        case '<': buffer.append("&lt;"); break;
+        case '>': buffer.append("&gt;"); break;
+        default: buffer.append(&data[pos], 1); break;
+        }
+    }
+    return buffer;
+}
+
+// -----------------------------------------------------------------------------------
+// Write a text model dump
+static void WriteDump(const char *pFile, const char *cmd, const aiScene *scene, IOStream *io, bool shortened) {
+    time_t tt = ::time(NULL);
+#if _WIN32
+    tm *p = gmtime(&tt);
+#else
+    struct tm now;
+    tm *p = gmtime_r(&tt, &now);
+#endif
+    ai_assert(nullptr != p);
+
+    std::string c = cmd;
+    std::string::size_type s;
+
+    // https://sourceforge.net/tracker/?func=detail&aid=3167364&group_id=226462&atid=1067632
+    // -- not allowed in XML comments
+    while ((s = c.find("--")) != std::string::npos) {
+        c[s] = '?';
+    }
+
+    // write header
+    std::string header(
+            "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
+            "<ASSIMP format_id=\"1\">\n\n"
+            "<!-- XML Model dump produced by assimp dump\n"
+            "  Library version: %u.%u.%u\n"
+            "  Source: %s\n"
+            "  Command line: %s\n"
+            "  %s\n"
+            "-->"
+            " \n\n"
+            "<Scene flags=\"%u\" postprocessing=\"%u\">\n");
+
+    const unsigned int majorVersion(aiGetVersionMajor());
+    const unsigned int minorVersion(aiGetVersionMinor());
+    const unsigned int rev(aiGetVersionRevision());
+    const char *curtime(asctime(p));
+    ioprintf(io, header.c_str(), majorVersion, minorVersion, rev, pFile, c.c_str(), curtime, scene->mFlags, 0u);
+
+    // write the node graph
+    WriteNode(scene->mRootNode, io, 0);
+
+#if 0
+    // write cameras
+    for (unsigned int i = 0; i < scene->mNumCameras;++i) {
+        aiCamera* cam  = scene->mCameras[i];
+        ConvertName(name,cam->mName);
+
+        // camera header
+        ioprintf(io,"\t<Camera parent=\"%s\">\n"
+            "\t\t<Vector3 name=\"up\"        > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Float   name=\"fov\"       > %f </Float>\n"
+            "\t\t<Float   name=\"aspect\"    > %f </Float>\n"
+            "\t\t<Float   name=\"near_clip\" > %f </Float>\n"
+            "\t\t<Float   name=\"far_clip\"  > %f </Float>\n"
+            "\t</Camera>\n",
+            name.data,
+            cam->mUp.x,cam->mUp.y,cam->mUp.z,
+            cam->mLookAt.x,cam->mLookAt.y,cam->mLookAt.z,
+            cam->mPosition.x,cam->mPosition.y,cam->mPosition.z,
+            cam->mHorizontalFOV,cam->mAspect,cam->mClipPlaneNear,cam->mClipPlaneFar,i);
+    }
+
+    // write lights
+    for (unsigned int i = 0; i < scene->mNumLights;++i) {
+        aiLight* l  = scene->mLights[i];
+        ConvertName(name,l->mName);
+
+        // light header
+        ioprintf(io,"\t<Light parent=\"%s\"> type=\"%s\"\n"
+            "\t\t<Vector3 name=\"diffuse\"   > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"specular\"  > %0 8f %0 8f %0 8f </Vector3>\n"
+            "\t\t<Vector3 name=\"ambient\"   > %0 8f %0 8f %0 8f </Vector3>\n",
+            name.data,
+            (l->mType == aiLightSource_DIRECTIONAL ? "directional" :
+            (l->mType == aiLightSource_POINT ? "point" : "spot" )),
+            l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b,
+            l->mColorSpecular.r,l->mColorSpecular.g,l->mColorSpecular.b,
+            l->mColorAmbient.r, l->mColorAmbient.g, l->mColorAmbient.b);
+
+        if (l->mType != aiLightSource_DIRECTIONAL) {
+            ioprintf(io,
+                "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
+                "\t\t<Float   name=\"atten_cst\" > %f </Float>\n"
+                "\t\t<Float   name=\"atten_lin\" > %f </Float>\n"
+                "\t\t<Float   name=\"atten_sqr\" > %f </Float>\n",
+                l->mPosition.x,l->mPosition.y,l->mPosition.z,
+                l->mAttenuationConstant,l->mAttenuationLinear,l->mAttenuationQuadratic);
+        }
+
+        if (l->mType != aiLightSource_POINT) {
+            ioprintf(io,
+                "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n",
+                l->mDirection.x,l->mDirection.y,l->mDirection.z);
+        }
+
+        if (l->mType == aiLightSource_SPOT) {
+            ioprintf(io,
+                "\t\t<Float   name=\"cone_out\" > %f </Float>\n"
+                "\t\t<Float   name=\"cone_inn\" > %f </Float>\n",
+                l->mAngleOuterCone,l->mAngleInnerCone);
+        }
+        ioprintf(io,"\t</Light>\n");
+    }
+#endif
+    aiString name;
+
+    // write textures
+    if (scene->mNumTextures) {
+        ioprintf(io, "<TextureList num=\"%u\">\n", scene->mNumTextures);
+        for (unsigned int i = 0; i < scene->mNumTextures; ++i) {
+            aiTexture *tex = scene->mTextures[i];
+            bool compressed = (tex->mHeight == 0);
+
+            // mesh header
+            ioprintf(io, "\t<Texture width=\"%u\" height=\"%u\" compressed=\"%s\"> \n",
+                    (compressed ? -1 : tex->mWidth), (compressed ? -1 : tex->mHeight),
+                    (compressed ? "true" : "false"));
+
+            if (compressed) {
+                ioprintf(io, "\t\t<Data length=\"%u\"> \n", tex->mWidth);
+
+                if (!shortened) {
+                    for (unsigned int n = 0; n < tex->mWidth; ++n) {
+                        ioprintf(io, "\t\t\t%2x", reinterpret_cast<uint8_t *>(tex->pcData)[n]);
+                        if (n && !(n % 50)) {
+                            ioprintf(io, "\n");
+                        }
+                    }
+                }
+            } else if (!shortened) {
+                ioprintf(io, "\t\t<Data length=\"%u\"> \n", tex->mWidth * tex->mHeight * 4);
+
+                // const unsigned int width = (unsigned int)std::log10((double)std::max(tex->mHeight,tex->mWidth))+1;
+                for (unsigned int y = 0; y < tex->mHeight; ++y) {
+                    for (unsigned int x = 0; x < tex->mWidth; ++x) {
+                        aiTexel *tx = tex->pcData + y * tex->mWidth + x;
+                        unsigned int r = tx->r, g = tx->g, b = tx->b, a = tx->a;
+                        ioprintf(io, "\t\t\t%2x %2x %2x %2x", r, g, b, a);
+
+                        // group by four for readability
+                        if (0 == (x + y * tex->mWidth) % 4) {
+                            ioprintf(io, "\n");
+                        }
+                    }
+                }
+            }
+            ioprintf(io, "\t\t</Data>\n\t</Texture>\n");
+        }
+        ioprintf(io, "</TextureList>\n");
+    }
+
+    // write materials
+    if (scene->mNumMaterials) {
+        ioprintf(io, "<MaterialList num=\"%u\">\n", scene->mNumMaterials);
+        for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
+            const aiMaterial *mat = scene->mMaterials[i];
+
+            ioprintf(io, "\t<Material>\n");
+            ioprintf(io, "\t\t<MatPropertyList  num=\"%u\">\n", mat->mNumProperties);
+            for (unsigned int n = 0; n < mat->mNumProperties; ++n) {
+
+                const aiMaterialProperty *prop = mat->mProperties[n];
+                const char *sz = "";
+                if (prop->mType == aiPTI_Float) {
+                    sz = "float";
+                } else if (prop->mType == aiPTI_Integer) {
+                    sz = "integer";
+                } else if (prop->mType == aiPTI_String) {
+                    sz = "string";
+                } else if (prop->mType == aiPTI_Buffer) {
+                    sz = "binary_buffer";
+                }
+
+                ioprintf(io, "\t\t\t<MatProperty key=\"%s\" \n\t\t\ttype=\"%s\" tex_usage=\"%s\" tex_index=\"%u\"",
+                        prop->mKey.data, sz,
+                        ::TextureTypeToString((aiTextureType)prop->mSemantic), prop->mIndex);
+
+                if (prop->mType == aiPTI_Float) {
+                    ioprintf(io, " size=\"%i\">\n\t\t\t\t",
+                            static_cast<int>(prop->mDataLength / sizeof(float)));
+
+                    for (unsigned int pp = 0; pp < prop->mDataLength / sizeof(float); ++pp) {
+                        ioprintf(io, "%f ", *((float *)(prop->mData + pp * sizeof(float))));
+                    }
+                } else if (prop->mType == aiPTI_Integer) {
+                    ioprintf(io, " size=\"%i\">\n\t\t\t\t",
+                            static_cast<int>(prop->mDataLength / sizeof(int)));
+
+                    for (unsigned int pp = 0; pp < prop->mDataLength / sizeof(int); ++pp) {
+                        ioprintf(io, "%i ", *((int *)(prop->mData + pp * sizeof(int))));
+                    }
+                } else if (prop->mType == aiPTI_Buffer) {
+                    ioprintf(io, " size=\"%i\">\n\t\t\t\t",
+                            static_cast<int>(prop->mDataLength));
+
+                    for (unsigned int pp = 0; pp < prop->mDataLength; ++pp) {
+                        ioprintf(io, "%2x ", prop->mData[pp]);
+                        if (pp && 0 == pp % 30) {
+                            ioprintf(io, "\n\t\t\t\t");
+                        }
+                    }
+                } else if (prop->mType == aiPTI_String) {
+                    ioprintf(io, ">\n\t\t\t\t\"%s\"", encodeXML(prop->mData + 4).c_str() /* skip length */);
+                }
+                ioprintf(io, "\n\t\t\t</MatProperty>\n");
+            }
+            ioprintf(io, "\t\t</MatPropertyList>\n");
+            ioprintf(io, "\t</Material>\n");
+        }
+        ioprintf(io, "</MaterialList>\n");
+    }
+
+    // write animations
+    if (scene->mNumAnimations) {
+        ioprintf(io, "<AnimationList num=\"%u\">\n", scene->mNumAnimations);
+        for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
+            aiAnimation *anim = scene->mAnimations[i];
+
+            // anim header
+            ConvertName(name, anim->mName);
+            ioprintf(io, "\t<Animation name=\"%s\" duration=\"%e\" tick_cnt=\"%e\">\n",
+                    name.data, anim->mDuration, anim->mTicksPerSecond);
+
+            // write bone animation channels
+            if (anim->mNumChannels) {
+                ioprintf(io, "\t\t<NodeAnimList num=\"%u\">\n", anim->mNumChannels);
+                for (unsigned int n = 0; n < anim->mNumChannels; ++n) {
+                    aiNodeAnim *nd = anim->mChannels[n];
+
+                    // node anim header
+                    ConvertName(name, nd->mNodeName);
+                    ioprintf(io, "\t\t\t<NodeAnim node=\"%s\">\n", name.data);
+
+                    if (!shortened) {
+                        // write position keys
+                        if (nd->mNumPositionKeys) {
+                            ioprintf(io, "\t\t\t\t<PositionKeyList num=\"%u\">\n", nd->mNumPositionKeys);
+                            for (unsigned int a = 0; a < nd->mNumPositionKeys; ++a) {
+                                aiVectorKey *vc = nd->mPositionKeys + a;
+                                ioprintf(io, "\t\t\t\t\t<PositionKey time=\"%e\">\n"
+                                             "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</PositionKey>\n",
+                                        vc->mTime, vc->mValue.x, vc->mValue.y, vc->mValue.z);
+                            }
+                            ioprintf(io, "\t\t\t\t</PositionKeyList>\n");
+                        }
+
+                        // write scaling keys
+                        if (nd->mNumScalingKeys) {
+                            ioprintf(io, "\t\t\t\t<ScalingKeyList num=\"%u\">\n", nd->mNumScalingKeys);
+                            for (unsigned int a = 0; a < nd->mNumScalingKeys; ++a) {
+                                aiVectorKey *vc = nd->mScalingKeys + a;
+                                ioprintf(io, "\t\t\t\t\t<ScalingKey time=\"%e\">\n"
+                                             "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</ScalingKey>\n",
+                                        vc->mTime, vc->mValue.x, vc->mValue.y, vc->mValue.z);
+                            }
+                            ioprintf(io, "\t\t\t\t</ScalingKeyList>\n");
+                        }
+
+                        // write rotation keys
+                        if (nd->mNumRotationKeys) {
+                            ioprintf(io, "\t\t\t\t<RotationKeyList num=\"%u\">\n", nd->mNumRotationKeys);
+                            for (unsigned int a = 0; a < nd->mNumRotationKeys; ++a) {
+                                aiQuatKey *vc = nd->mRotationKeys + a;
+                                ioprintf(io, "\t\t\t\t\t<RotationKey time=\"%e\">\n"
+                                             "\t\t\t\t\t\t%0 8f %0 8f %0 8f %0 8f\n\t\t\t\t\t</RotationKey>\n",
+                                        vc->mTime, vc->mValue.x, vc->mValue.y, vc->mValue.z, vc->mValue.w);
+                            }
+                            ioprintf(io, "\t\t\t\t</RotationKeyList>\n");
+                        }
+                    }
+                    ioprintf(io, "\t\t\t</NodeAnim>\n");
+                }
+                ioprintf(io, "\t\t</NodeAnimList>\n");
+            }
+            ioprintf(io, "\t</Animation>\n");
+        }
+        ioprintf(io, "</AnimationList>\n");
+    }
+
+    // write meshes
+    if (scene->mNumMeshes) {
+        ioprintf(io, "<MeshList num=\"%u\">\n", scene->mNumMeshes);
+        for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
+            aiMesh *mesh = scene->mMeshes[i];
+            // const unsigned int width = (unsigned int)std::log10((double)mesh->mNumVertices)+1;
+
+            // mesh header
+            ioprintf(io, "\t<Mesh types=\"%s %s %s %s\" material_index=\"%u\">\n",
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_POINT ? "points" : ""),
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_LINE ? "lines" : ""),
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE ? "triangles" : ""),
+                    (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON ? "polygons" : ""),
+                    mesh->mMaterialIndex);
+
+            // bones
+            if (mesh->mNumBones) {
+                ioprintf(io, "\t\t<BoneList num=\"%u\">\n", mesh->mNumBones);
+
+                for (unsigned int n = 0; n < mesh->mNumBones; ++n) {
+                    aiBone *bone = mesh->mBones[n];
+
+                    ConvertName(name, bone->mName);
+                    // bone header
+                    ioprintf(io, "\t\t\t<Bone name=\"%s\">\n"
+                                 "\t\t\t\t<Matrix4> \n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
+                                 "\t\t\t\t</Matrix4> \n",
+                            name.data,
+                            bone->mOffsetMatrix.a1, bone->mOffsetMatrix.a2, bone->mOffsetMatrix.a3, bone->mOffsetMatrix.a4,
+                            bone->mOffsetMatrix.b1, bone->mOffsetMatrix.b2, bone->mOffsetMatrix.b3, bone->mOffsetMatrix.b4,
+                            bone->mOffsetMatrix.c1, bone->mOffsetMatrix.c2, bone->mOffsetMatrix.c3, bone->mOffsetMatrix.c4,
+                            bone->mOffsetMatrix.d1, bone->mOffsetMatrix.d2, bone->mOffsetMatrix.d3, bone->mOffsetMatrix.d4);
+
+                    if (!shortened && bone->mNumWeights) {
+                        ioprintf(io, "\t\t\t\t<WeightList num=\"%u\">\n", bone->mNumWeights);
+
+                        // bone weights
+                        for (unsigned int a = 0; a < bone->mNumWeights; ++a) {
+                            aiVertexWeight *wght = bone->mWeights + a;
+
+                            ioprintf(io, "\t\t\t\t\t<Weight index=\"%u\">\n\t\t\t\t\t\t%f\n\t\t\t\t\t</Weight>\n",
+                                    wght->mVertexId, wght->mWeight);
+                        }
+                        ioprintf(io, "\t\t\t\t</WeightList>\n");
+                    }
+                    ioprintf(io, "\t\t\t</Bone>\n");
+                }
+                ioprintf(io, "\t\t</BoneList>\n");
+            }
+
+            // faces
+            if (!shortened && mesh->mNumFaces) {
+                ioprintf(io, "\t\t<FaceList num=\"%u\">\n", mesh->mNumFaces);
+                for (unsigned int n = 0; n < mesh->mNumFaces; ++n) {
+                    aiFace &f = mesh->mFaces[n];
+                    ioprintf(io, "\t\t\t<Face num=\"%u\">\n"
+                                 "\t\t\t\t",
+                            f.mNumIndices);
+
+                    for (unsigned int j = 0; j < f.mNumIndices; ++j)
+                        ioprintf(io, "%u ", f.mIndices[j]);
+
+                    ioprintf(io, "\n\t\t\t</Face>\n");
+                }
+                ioprintf(io, "\t\t</FaceList>\n");
+            }
+
+            // vertex positions
+            if (mesh->HasPositions()) {
+                ioprintf(io, "\t\t<Positions num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mVertices[n].x,
+                                mesh->mVertices[n].y,
+                                mesh->mVertices[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Positions>\n");
+            }
+
+            // vertex normals
+            if (mesh->HasNormals()) {
+                ioprintf(io, "\t\t<Normals num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mNormals[n].x,
+                                mesh->mNormals[n].y,
+                                mesh->mNormals[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Normals>\n");
+            }
+
+            // vertex tangents and bitangents
+            if (mesh->HasTangentsAndBitangents()) {
+                ioprintf(io, "\t\t<Tangents num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mTangents[n].x,
+                                mesh->mTangents[n].y,
+                                mesh->mTangents[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Tangents>\n");
+
+                ioprintf(io, "\t\t<Bitangents num=\"%u\" set=\"0\" num_components=\"3\"> \n", mesh->mNumVertices);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                mesh->mBitangents[n].x,
+                                mesh->mBitangents[n].y,
+                                mesh->mBitangents[n].z);
+                    }
+                }
+                ioprintf(io, "\t\t</Bitangents>\n");
+            }
+
+            // texture coordinates
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+                if (!mesh->mTextureCoords[a])
+                    break;
+
+                ioprintf(io, "\t\t<TextureCoords num=\"%u\" set=\"%u\" num_components=\"%u\"> \n", mesh->mNumVertices,
+                        a, mesh->mNumUVComponents[a]);
+
+                if (!shortened) {
+                    if (mesh->mNumUVComponents[a] == 3) {
+                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                            ioprintf(io, "\t\t%0 8f %0 8f %0 8f\n",
+                                    mesh->mTextureCoords[a][n].x,
+                                    mesh->mTextureCoords[a][n].y,
+                                    mesh->mTextureCoords[a][n].z);
+                        }
+                    } else {
+                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                            ioprintf(io, "\t\t%0 8f %0 8f\n",
+                                    mesh->mTextureCoords[a][n].x,
+                                    mesh->mTextureCoords[a][n].y);
+                        }
+                    }
+                }
+                ioprintf(io, "\t\t</TextureCoords>\n");
+            }
+
+            // vertex colors
+            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+                if (!mesh->mColors[a])
+                    break;
+                ioprintf(io, "\t\t<Colors num=\"%u\" set=\"%u\" num_components=\"4\"> \n", mesh->mNumVertices, a);
+                if (!shortened) {
+                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
+                        ioprintf(io, "\t\t%0 8f %0 8f %0 8f %0 8f\n",
+                                mesh->mColors[a][n].r,
+                                mesh->mColors[a][n].g,
+                                mesh->mColors[a][n].b,
+                                mesh->mColors[a][n].a);
+                    }
+                }
+                ioprintf(io, "\t\t</Colors>\n");
+            }
+            ioprintf(io, "\t</Mesh>\n");
+        }
+        ioprintf(io, "</MeshList>\n");
+    }
+    ioprintf(io, "</Scene>\n</ASSIMP>");
+}
+
+} // end of namespace AssxmlFileWriter
+
+void DumpSceneToAssxml(
+        const char *pFile, const char *cmd, IOSystem *pIOSystem,
+        const aiScene *pScene, bool shortened) {
+    std::unique_ptr<IOStream> file(pIOSystem->Open(pFile, "wt"));
+    if (!file.get()) {
+        throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
+    }
+
+    AssxmlFileWriter::WriteDump(pFile, cmd, pScene, file.get(), shortened);
+}
+
+} // end of namespace Assimp
diff --git a/code/Assxml/AssxmlFileWriter.h b/code/AssetLib/Assxml/AssxmlFileWriter.h
similarity index 100%
rename from code/Assxml/AssxmlFileWriter.h
rename to code/AssetLib/Assxml/AssxmlFileWriter.h
diff --git a/code/AssetLib/B3D/B3DImporter.cpp b/code/AssetLib/B3D/B3DImporter.cpp
new file mode 100644
index 000000000..ff595aaf1
--- /dev/null
+++ b/code/AssetLib/B3D/B3DImporter.cpp
@@ -0,0 +1,744 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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  B3DImporter.cpp
+ *  @brief Implementation of the b3d importer class
+ */
+
+#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
+
+// internal headers
+#include "AssetLib/B3D/B3DImporter.h"
+#include "PostProcessing/ConvertToLHProcess.h"
+#include "PostProcessing/TextureTransform.h"
+
+#include <assimp/StringUtils.h>
+#include <assimp/anim.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <memory>
+
+using namespace Assimp;
+using namespace std;
+
+static const aiImporterDesc desc = {
+    "BlitzBasic 3D Importer",
+    "",
+    "",
+    "http://www.blitzbasic.com/",
+    aiImporterFlags_SupportBinaryFlavour,
+    0,
+    0,
+    0,
+    0,
+    "b3d"
+};
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4018)
+#endif
+
+//#define DEBUG_B3D
+
+template <typename T>
+void DeleteAllBarePointers(std::vector<T> &x) {
+    for (auto p : x) {
+        delete p;
+    }
+}
+
+B3DImporter::~B3DImporter() {
+}
+
+// ------------------------------------------------------------------------------------------------
+bool B3DImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
+
+    size_t pos = pFile.find_last_of('.');
+    if (pos == string::npos) {
+        return false;
+    }
+
+    string ext = pFile.substr(pos + 1);
+    if (ext.size() != 3) {
+        return false;
+    }
+
+    return (ext[0] == 'b' || ext[0] == 'B') && (ext[1] == '3') && (ext[2] == 'd' || ext[2] == 'D');
+}
+
+// ------------------------------------------------------------------------------------------------
+// Loader meta information
+const aiImporterDesc *B3DImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::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 B3D file " + pFile + ".");
+    }
+
+    // check whether the .b3d file is large enough to contain
+    // at least one chunk.
+    size_t fileSize = file->FileSize();
+    if (fileSize < 8) {
+        throw DeadlyImportError("B3D File is too small.");
+    }
+
+    _pos = 0;
+    _buf.resize(fileSize);
+    file->Read(&_buf[0], 1, fileSize);
+    _stack.clear();
+
+    ReadBB3D(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+AI_WONT_RETURN void B3DImporter::Oops() {
+    throw DeadlyImportError("B3D Importer - INTERNAL ERROR");
+}
+
+// ------------------------------------------------------------------------------------------------
+AI_WONT_RETURN void B3DImporter::Fail(string str) {
+#ifdef DEBUG_B3D
+    ASSIMP_LOG_ERROR_F("Error in B3D file data: ", str);
+#endif
+    throw DeadlyImportError("B3D Importer - error in B3D file data: " + str);
+}
+
+// ------------------------------------------------------------------------------------------------
+int B3DImporter::ReadByte() {
+    if (_pos > _buf.size()) {
+        Fail("EOF");
+    }
+
+    return _buf[_pos++];
+}
+
+// ------------------------------------------------------------------------------------------------
+int B3DImporter::ReadInt() {
+    if (_pos + 4 > _buf.size()) {
+        Fail("EOF");
+    }
+
+    int n;
+    memcpy(&n, &_buf[_pos], 4);
+    _pos += 4;
+
+    return n;
+}
+
+// ------------------------------------------------------------------------------------------------
+float B3DImporter::ReadFloat() {
+    if (_pos + 4 > _buf.size()) {
+        Fail("EOF");
+    }
+
+    float n;
+    memcpy(&n, &_buf[_pos], 4);
+    _pos += 4;
+
+    return n;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector2D B3DImporter::ReadVec2() {
+    float x = ReadFloat();
+    float y = ReadFloat();
+    return aiVector2D(x, y);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiVector3D B3DImporter::ReadVec3() {
+    float x = ReadFloat();
+    float y = ReadFloat();
+    float z = ReadFloat();
+    return aiVector3D(x, y, z);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiQuaternion B3DImporter::ReadQuat() {
+    // (aramis_acg) Fix to adapt the loader to changed quat orientation
+    float w = -ReadFloat();
+    float x = ReadFloat();
+    float y = ReadFloat();
+    float z = ReadFloat();
+    return aiQuaternion(w, x, y, z);
+}
+
+// ------------------------------------------------------------------------------------------------
+string B3DImporter::ReadString() {
+    if (_pos > _buf.size()) {
+        Fail("EOF");
+    }
+    string str;
+    while (_pos < _buf.size()) {
+        char c = (char)ReadByte();
+        if (!c) {
+            return str;
+        }
+        str += c;
+    }
+    return string();
+}
+
+// ------------------------------------------------------------------------------------------------
+string B3DImporter::ReadChunk() {
+    string tag;
+    for (int i = 0; i < 4; ++i) {
+        tag += char(ReadByte());
+    }
+#ifdef DEBUG_B3D
+    ASSIMP_LOG_DEBUG_F("ReadChunk: ", tag);
+#endif
+    unsigned sz = (unsigned)ReadInt();
+    _stack.push_back(_pos + sz);
+    return tag;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ExitChunk() {
+    _pos = _stack.back();
+    _stack.pop_back();
+}
+
+// ------------------------------------------------------------------------------------------------
+size_t B3DImporter::ChunkSize() {
+    return _stack.back() - _pos;
+}
+// ------------------------------------------------------------------------------------------------
+
+template <class T>
+T *B3DImporter::to_array(const vector<T> &v) {
+    if (v.empty()) {
+        return 0;
+    }
+    T *p = new T[v.size()];
+    for (size_t i = 0; i < v.size(); ++i) {
+        p[i] = v[i];
+    }
+    return p;
+}
+
+// ------------------------------------------------------------------------------------------------
+template <class T>
+T **unique_to_array(vector<std::unique_ptr<T>> &v) {
+    if (v.empty()) {
+        return 0;
+    }
+    T **p = new T *[v.size()];
+    for (size_t i = 0; i < v.size(); ++i) {
+        p[i] = v[i].release();
+    }
+    return p;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadTEXS() {
+    while (ChunkSize()) {
+        string name = ReadString();
+        /*int flags=*/ReadInt();
+        /*int blend=*/ReadInt();
+        /*aiVector2D pos=*/ReadVec2();
+        /*aiVector2D scale=*/ReadVec2();
+        /*float rot=*/ReadFloat();
+
+        _textures.push_back(name);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadBRUS() {
+    int n_texs = ReadInt();
+    if (n_texs < 0 || n_texs > 8) {
+        Fail("Bad texture count");
+    }
+    while (ChunkSize()) {
+        string name = ReadString();
+        aiVector3D color = ReadVec3();
+        float alpha = ReadFloat();
+        float shiny = ReadFloat();
+        /*int blend=**/ ReadInt();
+        int fx = ReadInt();
+
+        std::unique_ptr<aiMaterial> mat(new aiMaterial);
+
+        // Name
+        aiString ainame(name);
+        mat->AddProperty(&ainame, AI_MATKEY_NAME);
+
+        // Diffuse color
+        mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
+
+        // Opacity
+        mat->AddProperty(&alpha, 1, AI_MATKEY_OPACITY);
+
+        // Specular color
+        aiColor3D speccolor(shiny, shiny, shiny);
+        mat->AddProperty(&speccolor, 1, AI_MATKEY_COLOR_SPECULAR);
+
+        // Specular power
+        float specpow = shiny * 128;
+        mat->AddProperty(&specpow, 1, AI_MATKEY_SHININESS);
+
+        // Double sided
+        if (fx & 0x10) {
+            int i = 1;
+            mat->AddProperty(&i, 1, AI_MATKEY_TWOSIDED);
+        }
+
+        //Textures
+        for (int i = 0; i < n_texs; ++i) {
+            int texid = ReadInt();
+            if (texid < -1 || (texid >= 0 && texid >= static_cast<int>(_textures.size()))) {
+                Fail("Bad texture id");
+            }
+            if (i == 0 && texid >= 0) {
+                aiString texname(_textures[texid]);
+                mat->AddProperty(&texname, AI_MATKEY_TEXTURE_DIFFUSE(0));
+            }
+        }
+        _materials.emplace_back(std::move(mat));
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadVRTS() {
+    _vflags = ReadInt();
+    _tcsets = ReadInt();
+    _tcsize = ReadInt();
+    if (_tcsets < 0 || _tcsets > 4 || _tcsize < 0 || _tcsize > 4) {
+        Fail("Bad texcoord data");
+    }
+
+    int sz = 12 + (_vflags & 1 ? 12 : 0) + (_vflags & 2 ? 16 : 0) + (_tcsets * _tcsize * 4);
+    size_t n_verts = ChunkSize() / sz;
+
+    int v0 = static_cast<int>(_vertices.size());
+    _vertices.resize(v0 + n_verts);
+
+    for (unsigned int i = 0; i < n_verts; ++i) {
+        Vertex &v = _vertices[v0 + i];
+
+        memset(v.bones, 0, sizeof(v.bones));
+        memset(v.weights, 0, sizeof(v.weights));
+
+        v.vertex = ReadVec3();
+
+        if (_vflags & 1) {
+            v.normal = ReadVec3();
+        }
+
+        if (_vflags & 2) {
+            ReadQuat(); //skip v 4bytes...
+        }
+
+        for (int j = 0; j < _tcsets; ++j) {
+            float t[4] = { 0, 0, 0, 0 };
+            for (int k = 0; k < _tcsize; ++k) {
+                t[k] = ReadFloat();
+            }
+            t[1] = 1 - t[1];
+            if (!j) {
+                v.texcoords = aiVector3D(t[0], t[1], t[2]);
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadTRIS(int v0) {
+    int matid = ReadInt();
+    if (matid == -1) {
+        matid = 0;
+    } else if (matid < 0 || matid >= (int)_materials.size()) {
+#ifdef DEBUG_B3D
+        ASSIMP_LOG_ERROR_F("material id=", matid);
+#endif
+        Fail("Bad material id");
+    }
+
+    std::unique_ptr<aiMesh> mesh(new aiMesh);
+
+    mesh->mMaterialIndex = matid;
+    mesh->mNumFaces = 0;
+    mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+    size_t n_tris = ChunkSize() / 12;
+    aiFace *face = mesh->mFaces = new aiFace[n_tris];
+
+    for (unsigned int i = 0; i < n_tris; ++i) {
+        int i0 = ReadInt() + v0;
+        int i1 = ReadInt() + v0;
+        int i2 = ReadInt() + v0;
+        if (i0 < 0 || i0 >= (int)_vertices.size() || i1 < 0 || i1 >= (int)_vertices.size() || i2 < 0 || i2 >= (int)_vertices.size()) {
+#ifdef DEBUG_B3D
+            ASSIMP_LOG_ERROR_F("Bad triangle index: i0=", i0, ", i1=", i1, ", i2=", i2);
+#endif
+            Fail("Bad triangle index");
+            continue;
+        }
+        face->mNumIndices = 3;
+        face->mIndices = new unsigned[3];
+        face->mIndices[0] = i0;
+        face->mIndices[1] = i1;
+        face->mIndices[2] = i2;
+        ++mesh->mNumFaces;
+        ++face;
+    }
+
+    _meshes.emplace_back(std::move(mesh));
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadMESH() {
+    /*int matid=*/ReadInt();
+
+    int v0 = static_cast<int>(_vertices.size());
+
+    while (ChunkSize()) {
+        string t = ReadChunk();
+        if (t == "VRTS") {
+            ReadVRTS();
+        } else if (t == "TRIS") {
+            ReadTRIS(v0);
+        }
+        ExitChunk();
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadBONE(int id) {
+    while (ChunkSize()) {
+        int vertex = ReadInt();
+        float weight = ReadFloat();
+        if (vertex < 0 || vertex >= (int)_vertices.size()) {
+            Fail("Bad vertex index");
+        }
+
+        Vertex &v = _vertices[vertex];
+        for (int i = 0; i < 4; ++i) {
+            if (!v.weights[i]) {
+                v.bones[i] = static_cast<unsigned char>(id);
+                v.weights[i] = weight;
+                break;
+            }
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadKEYS(aiNodeAnim *nodeAnim) {
+    vector<aiVectorKey> trans, scale;
+    vector<aiQuatKey> rot;
+    int flags = ReadInt();
+    while (ChunkSize()) {
+        int frame = ReadInt();
+        if (flags & 1) {
+            trans.push_back(aiVectorKey(frame, ReadVec3()));
+        }
+        if (flags & 2) {
+            scale.push_back(aiVectorKey(frame, ReadVec3()));
+        }
+        if (flags & 4) {
+            rot.push_back(aiQuatKey(frame, ReadQuat()));
+        }
+    }
+
+    if (flags & 1) {
+        nodeAnim->mNumPositionKeys = static_cast<unsigned int>(trans.size());
+        nodeAnim->mPositionKeys = to_array(trans);
+    }
+
+    if (flags & 2) {
+        nodeAnim->mNumScalingKeys = static_cast<unsigned int>(scale.size());
+        nodeAnim->mScalingKeys = to_array(scale);
+    }
+
+    if (flags & 4) {
+        nodeAnim->mNumRotationKeys = static_cast<unsigned int>(rot.size());
+        nodeAnim->mRotationKeys = to_array(rot);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadANIM() {
+    /*int flags=*/ReadInt();
+    int frames = ReadInt();
+    float fps = ReadFloat();
+
+    std::unique_ptr<aiAnimation> anim(new aiAnimation);
+
+    anim->mDuration = frames;
+    anim->mTicksPerSecond = fps;
+    _animations.emplace_back(std::move(anim));
+}
+
+// ------------------------------------------------------------------------------------------------
+aiNode *B3DImporter::ReadNODE(aiNode *parent) {
+
+    string name = ReadString();
+    aiVector3D t = ReadVec3();
+    aiVector3D s = ReadVec3();
+    aiQuaternion r = ReadQuat();
+
+    aiMatrix4x4 trans, scale, rot;
+
+    aiMatrix4x4::Translation(t, trans);
+    aiMatrix4x4::Scaling(s, scale);
+    rot = aiMatrix4x4(r.GetMatrix());
+
+    aiMatrix4x4 tform = trans * rot * scale;
+
+    int nodeid = static_cast<int>(_nodes.size());
+
+    aiNode *node = new aiNode(name);
+    _nodes.push_back(node);
+
+    node->mParent = parent;
+    node->mTransformation = tform;
+
+    std::unique_ptr<aiNodeAnim> nodeAnim;
+    vector<unsigned> meshes;
+    vector<aiNode *> children;
+
+    while (ChunkSize()) {
+        const string chunk = ReadChunk();
+        if (chunk == "MESH") {
+            unsigned int n = static_cast<unsigned int>(_meshes.size());
+            ReadMESH();
+            for (unsigned int i = n; i < static_cast<unsigned int>(_meshes.size()); ++i) {
+                meshes.push_back(i);
+            }
+        } else if (chunk == "BONE") {
+            ReadBONE(nodeid);
+        } else if (chunk == "ANIM") {
+            ReadANIM();
+        } else if (chunk == "KEYS") {
+            if (!nodeAnim) {
+                nodeAnim.reset(new aiNodeAnim);
+                nodeAnim->mNodeName = node->mName;
+            }
+            ReadKEYS(nodeAnim.get());
+        } else if (chunk == "NODE") {
+            aiNode *child = ReadNODE(node);
+            children.push_back(child);
+        }
+        ExitChunk();
+    }
+
+    if (nodeAnim) {
+        _nodeAnims.emplace_back(std::move(nodeAnim));
+    }
+
+    node->mNumMeshes = static_cast<unsigned int>(meshes.size());
+    node->mMeshes = to_array(meshes);
+
+    node->mNumChildren = static_cast<unsigned int>(children.size());
+    node->mChildren = to_array(children);
+
+    return node;
+}
+
+// ------------------------------------------------------------------------------------------------
+void B3DImporter::ReadBB3D(aiScene *scene) {
+
+    _textures.clear();
+
+    _materials.clear();
+
+    _vertices.clear();
+
+    _meshes.clear();
+
+    DeleteAllBarePointers(_nodes);
+    _nodes.clear();
+
+    _nodeAnims.clear();
+
+    _animations.clear();
+
+    string t = ReadChunk();
+    if (t == "BB3D") {
+        int version = ReadInt();
+
+        if (!DefaultLogger::isNullLogger()) {
+            char dmp[128];
+            ai_snprintf(dmp, 128, "B3D file format version: %i", version);
+            ASSIMP_LOG_INFO(dmp);
+        }
+
+        while (ChunkSize()) {
+            const string chunk = ReadChunk();
+            if (chunk == "TEXS") {
+                ReadTEXS();
+            } else if (chunk == "BRUS") {
+                ReadBRUS();
+            } else if (chunk == "NODE") {
+                ReadNODE(0);
+            }
+            ExitChunk();
+        }
+    }
+    ExitChunk();
+
+    if (!_nodes.size()) {
+        Fail("No nodes");
+    }
+
+    if (!_meshes.size()) {
+        Fail("No meshes");
+    }
+
+    // Fix nodes/meshes/bones
+    for (size_t i = 0; i < _nodes.size(); ++i) {
+        aiNode *node = _nodes[i];
+
+        for (size_t j = 0; j < node->mNumMeshes; ++j) {
+            aiMesh *mesh = _meshes[node->mMeshes[j]].get();
+
+            int n_tris = mesh->mNumFaces;
+            int n_verts = mesh->mNumVertices = n_tris * 3;
+
+            aiVector3D *mv = mesh->mVertices = new aiVector3D[n_verts], *mn = 0, *mc = 0;
+            if (_vflags & 1) {
+                mn = mesh->mNormals = new aiVector3D[n_verts];
+            }
+            if (_tcsets) {
+                mc = mesh->mTextureCoords[0] = new aiVector3D[n_verts];
+            }
+
+            aiFace *face = mesh->mFaces;
+
+            vector<vector<aiVertexWeight>> vweights(_nodes.size());
+
+            for (int vertIdx = 0; vertIdx < n_verts; vertIdx += 3) {
+                for (int faceIndex = 0; faceIndex < 3; ++faceIndex) {
+                    Vertex &v = _vertices[face->mIndices[faceIndex]];
+
+                    *mv++ = v.vertex;
+                    if (mn) *mn++ = v.normal;
+                    if (mc) *mc++ = v.texcoords;
+
+                    face->mIndices[faceIndex] = vertIdx + faceIndex;
+
+                    for (int k = 0; k < 4; ++k) {
+                        if (!v.weights[k])
+                            break;
+
+                        int bone = v.bones[k];
+                        float weight = v.weights[k];
+
+                        vweights[bone].push_back(aiVertexWeight(vertIdx + faceIndex, weight));
+                    }
+                }
+                ++face;
+            }
+
+            vector<aiBone *> bones;
+            for (size_t weightIndx = 0; weightIndx < vweights.size(); ++weightIndx) {
+                vector<aiVertexWeight> &weights = vweights[weightIndx];
+                if (!weights.size()) {
+                    continue;
+                }
+
+                aiBone *bone = new aiBone;
+                bones.push_back(bone);
+
+                aiNode *bnode = _nodes[weightIndx];
+
+                bone->mName = bnode->mName;
+                bone->mNumWeights = static_cast<unsigned int>(weights.size());
+                bone->mWeights = to_array(weights);
+
+                aiMatrix4x4 mat = bnode->mTransformation;
+                while (bnode->mParent) {
+                    bnode = bnode->mParent;
+                    mat = bnode->mTransformation * mat;
+                }
+                bone->mOffsetMatrix = mat.Inverse();
+            }
+            mesh->mNumBones = static_cast<unsigned int>(bones.size());
+            mesh->mBones = to_array(bones);
+        }
+    }
+
+    //nodes
+    scene->mRootNode = _nodes[0];
+    _nodes.clear(); // node ownership now belongs to scene
+
+    //material
+    if (!_materials.size()) {
+        _materials.emplace_back(std::unique_ptr<aiMaterial>(new aiMaterial));
+    }
+    scene->mNumMaterials = static_cast<unsigned int>(_materials.size());
+    scene->mMaterials = unique_to_array(_materials);
+
+    //meshes
+    scene->mNumMeshes = static_cast<unsigned int>(_meshes.size());
+    scene->mMeshes = unique_to_array(_meshes);
+
+    //animations
+    if (_animations.size() == 1 && _nodeAnims.size()) {
+
+        aiAnimation *anim = _animations.back().get();
+        anim->mNumChannels = static_cast<unsigned int>(_nodeAnims.size());
+        anim->mChannels = unique_to_array(_nodeAnims);
+
+        scene->mNumAnimations = static_cast<unsigned int>(_animations.size());
+        scene->mAnimations = unique_to_array(_animations);
+    }
+
+    // convert to RH
+    MakeLeftHandedProcess makeleft;
+    makeleft.Execute(scene);
+
+    FlipWindingOrderProcess flip;
+    flip.Execute(scene);
+}
+
+#endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER
diff --git a/code/B3D/B3DImporter.h b/code/AssetLib/B3D/B3DImporter.h
similarity index 100%
rename from code/B3D/B3DImporter.h
rename to code/AssetLib/B3D/B3DImporter.h
diff --git a/code/AssetLib/BVH/BVHLoader.cpp b/code/AssetLib/BVH/BVHLoader.cpp
new file mode 100644
index 000000000..9c22879d2
--- /dev/null
+++ b/code/AssetLib/BVH/BVHLoader.cpp
@@ -0,0 +1,543 @@
+/** Implementation of the BVH loader */
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
+
+#include "BVHLoader.h"
+#include <assimp/SkeletonMeshBuilder.h>
+#include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
+#include <map>
+#include <memory>
+
+using namespace Assimp;
+using namespace Assimp::Formatter;
+
+static const aiImporterDesc desc = {
+    "BVH Importer (MoCap)",
+    "",
+    "",
+    "",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "bvh"
+};
+
+// ------------------------------------------------------------------------------------------------
+// Constructor to be privately used by Importer
+BVHLoader::BVHLoader() :
+        mLine(),
+        mAnimTickDuration(),
+        mAnimNumFrames(),
+        noSkeletonMesh() {}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor, private as well
+BVHLoader::~BVHLoader() {}
+
+// ------------------------------------------------------------------------------------------------
+// Returns whether the class can handle the format of the given file.
+bool BVHLoader::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool cs) const {
+    // check file extension
+    const std::string extension = GetExtension(pFile);
+
+    if (extension == "bvh")
+        return true;
+
+    if ((!extension.length() || cs) && pIOHandler) {
+        const char *tokens[] = { "HIERARCHY" };
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
+    }
+    return false;
+}
+
+// ------------------------------------------------------------------------------------------------
+void BVHLoader::SetupProperties(const Importer *pImp) {
+    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES, 0) != 0;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Loader meta information
+const aiImporterDesc *BVHLoader::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Imports the given file into the given scene structure.
+void BVHLoader::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
+    mFileName = pFile;
+
+    // read file into memory
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile));
+    if (file.get() == nullptr) {
+        throw DeadlyImportError("Failed to open file " + pFile + ".");
+    }
+
+    size_t fileSize = file->FileSize();
+    if (fileSize == 0) {
+        throw DeadlyImportError("File is too small.");
+    }
+
+    mBuffer.resize(fileSize);
+    file->Read(&mBuffer.front(), 1, fileSize);
+
+    // start reading
+    mReader = mBuffer.begin();
+    mLine = 1;
+    ReadStructure(pScene);
+
+    if (!noSkeletonMesh) {
+        // build a dummy mesh for the skeleton so that we see something at least
+        SkeletonMeshBuilder meshBuilder(pScene);
+    }
+
+    // construct an animation from all the motion data we read
+    CreateAnimation(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the file
+void BVHLoader::ReadStructure(aiScene *pScene) {
+    // first comes hierarchy
+    std::string header = GetNextToken();
+    if (header != "HIERARCHY")
+        ThrowException("Expected header string \"HIERARCHY\".");
+    ReadHierarchy(pScene);
+
+    // then comes the motion data
+    std::string motion = GetNextToken();
+    if (motion != "MOTION")
+        ThrowException("Expected beginning of motion data \"MOTION\".");
+    ReadMotion(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the hierarchy
+void BVHLoader::ReadHierarchy(aiScene *pScene) {
+    std::string root = GetNextToken();
+    if (root != "ROOT")
+        ThrowException("Expected root node \"ROOT\".");
+
+    // Go read the hierarchy from here
+    pScene->mRootNode = ReadNode();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a node and recursively its childs and returns the created node;
+aiNode *BVHLoader::ReadNode() {
+    // first token is name
+    std::string nodeName = GetNextToken();
+    if (nodeName.empty() || nodeName == "{")
+        ThrowException(format() << "Expected node name, but found \"" << nodeName << "\".");
+
+    // then an opening brace should follow
+    std::string openBrace = GetNextToken();
+    if (openBrace != "{")
+        ThrowException(format() << "Expected opening brace \"{\", but found \"" << openBrace << "\".");
+
+    // Create a node
+    aiNode *node = new aiNode(nodeName);
+    std::vector<aiNode *> childNodes;
+
+    // and create an bone entry for it
+    mNodes.push_back(Node(node));
+    Node &internNode = mNodes.back();
+
+    // now read the node's contents
+    std::string siteToken;
+    while (1) {
+        std::string token = GetNextToken();
+
+        // node offset to parent node
+        if (token == "OFFSET")
+            ReadNodeOffset(node);
+        else if (token == "CHANNELS")
+            ReadNodeChannels(internNode);
+        else if (token == "JOINT") {
+            // child node follows
+            aiNode *child = ReadNode();
+            child->mParent = node;
+            childNodes.push_back(child);
+        } else if (token == "End") {
+            // The real symbol is "End Site". Second part comes in a separate token
+            siteToken.clear();
+            siteToken = GetNextToken();
+            if (siteToken != "Site")
+                ThrowException(format() << "Expected \"End Site\" keyword, but found \"" << token << " " << siteToken << "\".");
+
+            aiNode *child = ReadEndSite(nodeName);
+            child->mParent = node;
+            childNodes.push_back(child);
+        } else if (token == "}") {
+            // we're done with that part of the hierarchy
+            break;
+        } else {
+            // everything else is a parse error
+            ThrowException(format() << "Unknown keyword \"" << token << "\".");
+        }
+    }
+
+    // add the child nodes if there are any
+    if (childNodes.size() > 0) {
+        node->mNumChildren = static_cast<unsigned int>(childNodes.size());
+        node->mChildren = new aiNode *[node->mNumChildren];
+        std::copy(childNodes.begin(), childNodes.end(), node->mChildren);
+    }
+
+    // and return the sub-hierarchy we built here
+    return node;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads an end node and returns the created node.
+aiNode *BVHLoader::ReadEndSite(const std::string &pParentName) {
+    // check opening brace
+    std::string openBrace = GetNextToken();
+    if (openBrace != "{")
+        ThrowException(format() << "Expected opening brace \"{\", but found \"" << openBrace << "\".");
+
+    // Create a node
+    aiNode *node = new aiNode("EndSite_" + pParentName);
+
+    // now read the node's contents. Only possible entry is "OFFSET"
+    std::string token;
+    while (1) {
+        token.clear();
+        token = GetNextToken();
+
+        // end node's offset
+        if (token == "OFFSET") {
+            ReadNodeOffset(node);
+        } else if (token == "}") {
+            // we're done with the end node
+            break;
+        } else {
+            // everything else is a parse error
+            ThrowException(format() << "Unknown keyword \"" << token << "\".");
+        }
+    }
+
+    // and return the sub-hierarchy we built here
+    return node;
+}
+// ------------------------------------------------------------------------------------------------
+// Reads a node offset for the given node
+void BVHLoader::ReadNodeOffset(aiNode *pNode) {
+    // Offset consists of three floats to read
+    aiVector3D offset;
+    offset.x = GetNextTokenAsFloat();
+    offset.y = GetNextTokenAsFloat();
+    offset.z = GetNextTokenAsFloat();
+
+    // build a transformation matrix from it
+    pNode->mTransformation = aiMatrix4x4(1.0f, 0.0f, 0.0f, offset.x,
+            0.0f, 1.0f, 0.0f, offset.y,
+            0.0f, 0.0f, 1.0f, offset.z,
+            0.0f, 0.0f, 0.0f, 1.0f);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the animation channels for the given node
+void BVHLoader::ReadNodeChannels(BVHLoader::Node &pNode) {
+    // number of channels. Use the float reader because we're lazy
+    float numChannelsFloat = GetNextTokenAsFloat();
+    unsigned int numChannels = (unsigned int)numChannelsFloat;
+
+    for (unsigned int a = 0; a < numChannels; a++) {
+        std::string channelToken = GetNextToken();
+
+        if (channelToken == "Xposition")
+            pNode.mChannels.push_back(Channel_PositionX);
+        else if (channelToken == "Yposition")
+            pNode.mChannels.push_back(Channel_PositionY);
+        else if (channelToken == "Zposition")
+            pNode.mChannels.push_back(Channel_PositionZ);
+        else if (channelToken == "Xrotation")
+            pNode.mChannels.push_back(Channel_RotationX);
+        else if (channelToken == "Yrotation")
+            pNode.mChannels.push_back(Channel_RotationY);
+        else if (channelToken == "Zrotation")
+            pNode.mChannels.push_back(Channel_RotationZ);
+        else
+            ThrowException(format() << "Invalid channel specifier \"" << channelToken << "\".");
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the motion data
+void BVHLoader::ReadMotion(aiScene * /*pScene*/) {
+    // Read number of frames
+    std::string tokenFrames = GetNextToken();
+    if (tokenFrames != "Frames:")
+        ThrowException(format() << "Expected frame count \"Frames:\", but found \"" << tokenFrames << "\".");
+
+    float numFramesFloat = GetNextTokenAsFloat();
+    mAnimNumFrames = (unsigned int)numFramesFloat;
+
+    // Read frame duration
+    std::string tokenDuration1 = GetNextToken();
+    std::string tokenDuration2 = GetNextToken();
+    if (tokenDuration1 != "Frame" || tokenDuration2 != "Time:")
+        ThrowException(format() << "Expected frame duration \"Frame Time:\", but found \"" << tokenDuration1 << " " << tokenDuration2 << "\".");
+
+    mAnimTickDuration = GetNextTokenAsFloat();
+
+    // resize value vectors for each node
+    for (std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
+        it->mChannelValues.reserve(it->mChannels.size() * mAnimNumFrames);
+
+    // now read all the data and store it in the corresponding node's value vector
+    for (unsigned int frame = 0; frame < mAnimNumFrames; ++frame) {
+        // on each line read the values for all nodes
+        for (std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it) {
+            // get as many values as the node has channels
+            for (unsigned int c = 0; c < it->mChannels.size(); ++c)
+                it->mChannelValues.push_back(GetNextTokenAsFloat());
+        }
+
+        // after one frame worth of values for all nodes there should be a newline, but we better don't rely on it
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Retrieves the next token
+std::string BVHLoader::GetNextToken() {
+    // skip any preceding whitespace
+    while (mReader != mBuffer.end()) {
+        if (!isspace(*mReader))
+            break;
+
+        // count lines
+        if (*mReader == '\n')
+            mLine++;
+
+        ++mReader;
+    }
+
+    // collect all chars till the next whitespace. BVH is easy in respect to that.
+    std::string token;
+    while (mReader != mBuffer.end()) {
+        if (isspace(*mReader))
+            break;
+
+        token.push_back(*mReader);
+        ++mReader;
+
+        // little extra logic to make sure braces are counted correctly
+        if (token == "{" || token == "}")
+            break;
+    }
+
+    // empty token means end of file, which is just fine
+    return token;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads the next token as a float
+float BVHLoader::GetNextTokenAsFloat() {
+    std::string token = GetNextToken();
+    if (token.empty())
+        ThrowException("Unexpected end of file while trying to read a float");
+
+    // check if the float is valid by testing if the atof() function consumed every char of the token
+    const char *ctoken = token.c_str();
+    float result = 0.0f;
+    ctoken = fast_atoreal_move<float>(ctoken, result);
+
+    if (ctoken != token.c_str() + token.length())
+        ThrowException(format() << "Expected a floating point number, but found \"" << token << "\".");
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Aborts the file reading with an exception
+AI_WONT_RETURN void BVHLoader::ThrowException(const std::string &pError) {
+    throw DeadlyImportError(format() << mFileName << ":" << mLine << " - " << pError);
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructs an animation for the motion data and stores it in the given scene
+void BVHLoader::CreateAnimation(aiScene *pScene) {
+    // create the animation
+    pScene->mNumAnimations = 1;
+    pScene->mAnimations = new aiAnimation *[1];
+    aiAnimation *anim = new aiAnimation;
+    pScene->mAnimations[0] = anim;
+
+    // put down the basic parameters
+    anim->mName.Set("Motion");
+    anim->mTicksPerSecond = 1.0 / double(mAnimTickDuration);
+    anim->mDuration = double(mAnimNumFrames - 1);
+
+    // now generate the tracks for all nodes
+    anim->mNumChannels = static_cast<unsigned int>(mNodes.size());
+    anim->mChannels = new aiNodeAnim *[anim->mNumChannels];
+
+    // FIX: set the array elements to NULL to ensure proper deletion if an exception is thrown
+    for (unsigned int i = 0; i < anim->mNumChannels; ++i)
+        anim->mChannels[i] = NULL;
+
+    for (unsigned int a = 0; a < anim->mNumChannels; a++) {
+        const Node &node = mNodes[a];
+        const std::string nodeName = std::string(node.mNode->mName.data);
+        aiNodeAnim *nodeAnim = new aiNodeAnim;
+        anim->mChannels[a] = nodeAnim;
+        nodeAnim->mNodeName.Set(nodeName);
+        std::map<BVHLoader::ChannelType, int> channelMap;
+
+        //Build map of channels
+        for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel) {
+            channelMap[node.mChannels[channel]] = channel;
+        }
+
+        // translational part, if given
+        if (node.mChannels.size() == 6) {
+            nodeAnim->mNumPositionKeys = mAnimNumFrames;
+            nodeAnim->mPositionKeys = new aiVectorKey[mAnimNumFrames];
+            aiVectorKey *poskey = nodeAnim->mPositionKeys;
+            for (unsigned int fr = 0; fr < mAnimNumFrames; ++fr) {
+                poskey->mTime = double(fr);
+
+                // Now compute all translations
+                for (BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel + 1)) {
+                    //Find channel in node
+                    std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
+
+                    if (mapIter == channelMap.end())
+                        throw DeadlyImportError("Missing position channel in node " + nodeName);
+                    else {
+                        int channelIdx = mapIter->second;
+                        switch (channel) {
+                        case Channel_PositionX:
+                            poskey->mValue.x = node.mChannelValues[fr * node.mChannels.size() + channelIdx];
+                            break;
+                        case Channel_PositionY:
+                            poskey->mValue.y = node.mChannelValues[fr * node.mChannels.size() + channelIdx];
+                            break;
+                        case Channel_PositionZ:
+                            poskey->mValue.z = node.mChannelValues[fr * node.mChannels.size() + channelIdx];
+                            break;
+
+                        default:
+                            break;
+                        }
+                    }
+                }
+                ++poskey;
+            }
+        } else {
+            // if no translation part is given, put a default sequence
+            aiVector3D nodePos(node.mNode->mTransformation.a4, node.mNode->mTransformation.b4, node.mNode->mTransformation.c4);
+            nodeAnim->mNumPositionKeys = 1;
+            nodeAnim->mPositionKeys = new aiVectorKey[1];
+            nodeAnim->mPositionKeys[0].mTime = 0.0;
+            nodeAnim->mPositionKeys[0].mValue = nodePos;
+        }
+
+        // rotation part. Always present. First find value offsets
+        {
+
+            // Then create the number of rotation keys
+            nodeAnim->mNumRotationKeys = mAnimNumFrames;
+            nodeAnim->mRotationKeys = new aiQuatKey[mAnimNumFrames];
+            aiQuatKey *rotkey = nodeAnim->mRotationKeys;
+            for (unsigned int fr = 0; fr < mAnimNumFrames; ++fr) {
+                aiMatrix4x4 temp;
+                aiMatrix3x3 rotMatrix;
+                for (BVHLoader::ChannelType channel = Channel_RotationX; channel <= Channel_RotationZ; channel = (BVHLoader::ChannelType)(channel + 1)) {
+                    //Find channel in node
+                    std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
+
+                    if (mapIter == channelMap.end())
+                        throw DeadlyImportError("Missing rotation channel in node " + nodeName);
+                    else {
+                        int channelIdx = mapIter->second;
+                        // translate ZXY euler angels into a quaternion
+                        const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
+
+                        // Compute rotation transformations in the right order
+                        switch (channel) {
+                        case Channel_RotationX:
+                            aiMatrix4x4::RotationX(angle, temp);
+                            rotMatrix *= aiMatrix3x3(temp);
+                            break;
+                        case Channel_RotationY:
+                            aiMatrix4x4::RotationY(angle, temp);
+                            rotMatrix *= aiMatrix3x3(temp);
+                            break;
+                        case Channel_RotationZ:
+                            aiMatrix4x4::RotationZ(angle, temp);
+                            rotMatrix *= aiMatrix3x3(temp);
+                            break;
+                        default:
+                            break;
+                        }
+                    }
+                }
+
+                rotkey->mTime = double(fr);
+                rotkey->mValue = aiQuaternion(rotMatrix);
+                ++rotkey;
+            }
+        }
+
+        // scaling part. Always just a default track
+        {
+            nodeAnim->mNumScalingKeys = 1;
+            nodeAnim->mScalingKeys = new aiVectorKey[1];
+            nodeAnim->mScalingKeys[0].mTime = 0.0;
+            nodeAnim->mScalingKeys[0].mValue.Set(1.0f, 1.0f, 1.0f);
+        }
+    }
+}
+
+#endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER
diff --git a/code/BVH/BVHLoader.h b/code/AssetLib/BVH/BVHLoader.h
similarity index 82%
rename from code/BVH/BVHLoader.h
rename to code/AssetLib/BVH/BVHLoader.h
index 93a3e5e83..c2ecbd102 100644
--- a/code/BVH/BVHLoader.h
+++ b/code/AssetLib/BVH/BVHLoader.h
@@ -53,8 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 struct aiNode;
 
-namespace Assimp
-{
+namespace Assimp {
 
 // --------------------------------------------------------------------------------
 /** Loader class to read Motion Capturing data from a .bvh file.
@@ -63,12 +62,10 @@ namespace Assimp
  * the hierarchy. It contains no actual mesh data, but we generate a dummy mesh
  * inside the loader just to be able to see something.
 */
-class BVHLoader : public BaseImporter
-{
+class BVHLoader : public BaseImporter {
 
     /** Possible animation channels for which the motion data holds the values */
-    enum ChannelType
-    {
+    enum ChannelType {
         Channel_PositionX,
         Channel_PositionY,
         Channel_PositionZ,
@@ -78,61 +75,57 @@ class BVHLoader : public BaseImporter
     };
 
     /** Collected list of node. Will be bones of the dummy mesh some day, addressed by their array index */
-    struct Node
-    {
-        const aiNode* mNode;
+    struct Node {
+        const aiNode *mNode;
         std::vector<ChannelType> mChannels;
         std::vector<float> mChannelValues; // motion data values for that node. Of size NumChannels * NumFrames
 
-        Node()
-        : mNode(nullptr)
-        { }
+        Node() :
+                mNode(nullptr) {}
 
-        explicit Node( const aiNode* pNode) : mNode( pNode) { }
+        explicit Node(const aiNode *pNode) :
+                mNode(pNode) {}
     };
 
 public:
-
     BVHLoader();
     ~BVHLoader();
 
 public:
     /** 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 cs) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool cs) const;
 
-    void SetupProperties(const Importer* pImp);
-    const aiImporterDesc* GetInfo () const;
+    void SetupProperties(const Importer *pImp);
+    const aiImporterDesc *GetInfo() const;
 
 protected:
-
-
     /** Imports the given file into the given scene structure.
      * See BaseImporter::InternReadFile() for details
      */
-    void InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
 
 protected:
     /** Reads the file */
-    void ReadStructure( aiScene* pScene);
+    void ReadStructure(aiScene *pScene);
 
     /** Reads the hierarchy */
-    void ReadHierarchy( aiScene* pScene);
+    void ReadHierarchy(aiScene *pScene);
 
     /** Reads a node and recursively its childs and returns the created node. */
-    aiNode* ReadNode();
+    aiNode *ReadNode();
 
     /** Reads an end node and returns the created node. */
-    aiNode* ReadEndSite( const std::string& pParentName);
+    aiNode *ReadEndSite(const std::string &pParentName);
 
     /** Reads a node offset for the given node */
-    void ReadNodeOffset( aiNode* pNode);
+    void ReadNodeOffset(aiNode *pNode);
 
     /** Reads the animation channels into the given node */
-    void ReadNodeChannels( BVHLoader::Node& pNode);
+    void ReadNodeChannels(BVHLoader::Node &pNode);
 
     /** Reads the motion data */
-    void ReadMotion( aiScene* pScene);
+    void ReadMotion(aiScene *pScene);
 
     /** Retrieves the next token */
     std::string GetNextToken();
@@ -141,10 +134,10 @@ protected:
     float GetNextTokenAsFloat();
 
     /** Aborts the file reading with an exception */
-    AI_WONT_RETURN void ThrowException( const std::string& pError) AI_WONT_RETURN_SUFFIX;
+    AI_WONT_RETURN void ThrowException(const std::string &pError) AI_WONT_RETURN_SUFFIX;
 
     /** Constructs an animation for the motion data and stores it in the given scene */
-    void CreateAnimation( aiScene* pScene);
+    void CreateAnimation(aiScene *pScene);
 
 protected:
     /** Filename, for a verbose error message */
diff --git a/code/Blender/BlenderBMesh.cpp b/code/AssetLib/Blender/BlenderBMesh.cpp
similarity index 55%
rename from code/Blender/BlenderBMesh.cpp
rename to code/AssetLib/Blender/BlenderBMesh.cpp
index 937d9d073..d5412273e 100644
--- a/code/Blender/BlenderBMesh.cpp
+++ b/code/AssetLib/Blender/BlenderBMesh.cpp
@@ -44,137 +44,117 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 
+#include "BlenderBMesh.h"
 #include "BlenderDNA.h"
 #include "BlenderScene.h"
-#include "BlenderBMesh.h"
 #include "BlenderTessellator.h"
 
-namespace Assimp
-{
-    template< > const char* LogFunctions< BlenderBMeshConverter >::Prefix()
-    {
-        static auto prefix = "BLEND_BMESH: ";
-        return prefix;
-    }
+namespace Assimp {
+template <>
+const char *LogFunctions<BlenderBMeshConverter>::Prefix() {
+    static auto prefix = "BLEND_BMESH: ";
+    return prefix;
 }
+} // namespace Assimp
 
 using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
 // ------------------------------------------------------------------------------------------------
-BlenderBMeshConverter::BlenderBMeshConverter( const Mesh* mesh ):
-    BMesh( mesh ),
-    triMesh( NULL )
-{
+BlenderBMeshConverter::BlenderBMeshConverter(const Mesh *mesh) :
+        BMesh(mesh),
+        triMesh(nullptr) {
+    ai_assert(nullptr != mesh);
 }
 
 // ------------------------------------------------------------------------------------------------
-BlenderBMeshConverter::~BlenderBMeshConverter( )
-{
-    DestroyTriMesh( );
+BlenderBMeshConverter::~BlenderBMeshConverter() {
+    DestroyTriMesh();
 }
 
 // ------------------------------------------------------------------------------------------------
-bool BlenderBMeshConverter::ContainsBMesh( ) const
-{
+bool BlenderBMeshConverter::ContainsBMesh() const {
     // TODO - Should probably do some additional verification here
     return BMesh->totpoly && BMesh->totloop && BMesh->totvert;
 }
 
 // ------------------------------------------------------------------------------------------------
-const Mesh* BlenderBMeshConverter::TriangulateBMesh( )
-{
-    AssertValidMesh( );
-    AssertValidSizes( );
-    PrepareTriMesh( );
+const Mesh *BlenderBMeshConverter::TriangulateBMesh() {
+    AssertValidMesh();
+    AssertValidSizes();
+    PrepareTriMesh();
 
-    for ( int i = 0; i < BMesh->totpoly; ++i )
-    {
-        const MPoly& poly = BMesh->mpoly[ i ];
-        ConvertPolyToFaces( poly );
+    for (int i = 0; i < BMesh->totpoly; ++i) {
+        const MPoly &poly = BMesh->mpoly[i];
+        ConvertPolyToFaces(poly);
     }
 
     return triMesh;
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AssertValidMesh( )
-{
-    if ( !ContainsBMesh( ) )
-    {
-        ThrowException( "BlenderBMeshConverter requires a BMesh with \"polygons\" - please call BlenderBMeshConverter::ContainsBMesh to check this first" );
+void BlenderBMeshConverter::AssertValidMesh() {
+    if (!ContainsBMesh()) {
+        ThrowException("BlenderBMeshConverter requires a BMesh with \"polygons\" - please call BlenderBMeshConverter::ContainsBMesh to check this first");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AssertValidSizes( )
-{
-    if ( BMesh->totpoly != static_cast<int>( BMesh->mpoly.size( ) ) )
-    {
-        ThrowException( "BMesh poly array has incorrect size" );
+void BlenderBMeshConverter::AssertValidSizes() {
+    if (BMesh->totpoly != static_cast<int>(BMesh->mpoly.size())) {
+        ThrowException("BMesh poly array has incorrect size");
     }
-    if ( BMesh->totloop != static_cast<int>( BMesh->mloop.size( ) ) )
-    {
-        ThrowException( "BMesh loop array has incorrect size" );
+    if (BMesh->totloop != static_cast<int>(BMesh->mloop.size())) {
+        ThrowException("BMesh loop array has incorrect size");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::PrepareTriMesh( )
-{
-    if ( triMesh )
-    {
-        DestroyTriMesh( );
+void BlenderBMeshConverter::PrepareTriMesh() {
+    if (triMesh) {
+        DestroyTriMesh();
     }
 
-    triMesh = new Mesh( *BMesh );
+    triMesh = new Mesh(*BMesh);
     triMesh->totface = 0;
-    triMesh->mface.clear( );
+    triMesh->mface.clear();
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::DestroyTriMesh( )
-{
+void BlenderBMeshConverter::DestroyTriMesh() {
     delete triMesh;
-    triMesh = NULL;
+    triMesh = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::ConvertPolyToFaces( const MPoly& poly )
-{
-    const MLoop* polyLoop = &BMesh->mloop[ poly.loopstart ];
+void BlenderBMeshConverter::ConvertPolyToFaces(const MPoly &poly) {
+    const MLoop *polyLoop = &BMesh->mloop[poly.loopstart];
 
-    if ( poly.totloop == 3 || poly.totloop == 4 )
-    {
-        AddFace( polyLoop[ 0 ].v, polyLoop[ 1 ].v, polyLoop[ 2 ].v, poly.totloop == 4 ? polyLoop[ 3 ].v : 0 );
+    if (poly.totloop == 3 || poly.totloop == 4) {
+        AddFace(polyLoop[0].v, polyLoop[1].v, polyLoop[2].v, poly.totloop == 4 ? polyLoop[3].v : 0);
 
         // UVs are optional, so only convert when present.
-        if ( BMesh->mloopuv.size() )
-        {
-            if ( (poly.loopstart + poly.totloop ) > static_cast<int>( BMesh->mloopuv.size() ) )
-            {
-                ThrowException( "BMesh uv loop array has incorrect size" );
+        if (BMesh->mloopuv.size()) {
+            if ((poly.loopstart + poly.totloop) > static_cast<int>(BMesh->mloopuv.size())) {
+                ThrowException("BMesh uv loop array has incorrect size");
             }
-            const MLoopUV* loopUV = &BMesh->mloopuv[ poly.loopstart ];
-            AddTFace( loopUV[ 0 ].uv, loopUV[ 1 ].uv, loopUV[ 2 ].uv, poly.totloop == 4 ? loopUV[ 3 ].uv : 0 );
+            const MLoopUV *loopUV = &BMesh->mloopuv[poly.loopstart];
+            AddTFace(loopUV[0].uv, loopUV[1].uv, loopUV[2].uv, poly.totloop == 4 ? loopUV[3].uv : 0);
         }
-    }
-    else if ( poly.totloop > 4 )
-    {
+    } else if (poly.totloop > 4) {
 #if ASSIMP_BLEND_WITH_GLU_TESSELLATE
-        BlenderTessellatorGL tessGL( *this );
-        tessGL.Tessellate( polyLoop, poly.totloop, triMesh->mvert );
+        BlenderTessellatorGL tessGL(*this);
+        tessGL.Tessellate(polyLoop, poly.totloop, triMesh->mvert);
 #elif ASSIMP_BLEND_WITH_POLY_2_TRI
-        BlenderTessellatorP2T tessP2T( *this );
-        tessP2T.Tessellate( polyLoop, poly.totloop, triMesh->mvert );
+        BlenderTessellatorP2T tessP2T(*this);
+        tessP2T.Tessellate(polyLoop, poly.totloop, triMesh->mvert);
 #endif
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AddFace( int v1, int v2, int v3, int v4 )
-{
+void BlenderBMeshConverter::AddFace(int v1, int v2, int v3, int v4) {
     MFace face;
     face.v1 = v1;
     face.v2 = v2;
@@ -183,24 +163,22 @@ void BlenderBMeshConverter::AddFace( int v1, int v2, int v3, int v4 )
     face.flag = 0;
     // TODO - Work out how materials work
     face.mat_nr = 0;
-    triMesh->mface.push_back( face );
-    triMesh->totface = static_cast<int>(triMesh->mface.size( ));
+    triMesh->mface.push_back(face);
+    triMesh->totface = static_cast<int>(triMesh->mface.size());
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderBMeshConverter::AddTFace( const float* uv1, const float *uv2, const float *uv3, const float* uv4 )
-{
+void BlenderBMeshConverter::AddTFace(const float *uv1, const float *uv2, const float *uv3, const float *uv4) {
     MTFace mtface;
-    memcpy( &mtface.uv[ 0 ], uv1, sizeof(float) * 2 );
-    memcpy( &mtface.uv[ 1 ], uv2, sizeof(float) * 2 );
-    memcpy( &mtface.uv[ 2 ], uv3, sizeof(float) * 2 );
+    memcpy(&mtface.uv[0], uv1, sizeof(float) * 2);
+    memcpy(&mtface.uv[1], uv2, sizeof(float) * 2);
+    memcpy(&mtface.uv[2], uv3, sizeof(float) * 2);
 
-    if ( uv4 )
-    {
-        memcpy( &mtface.uv[ 3 ], uv4, sizeof(float) * 2 );
+    if (uv4) {
+        memcpy(&mtface.uv[3], uv4, sizeof(float) * 2);
     }
 
-    triMesh->mtface.push_back( mtface );
+    triMesh->mtface.push_back(mtface);
 }
 
 #endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
diff --git a/code/Blender/BlenderBMesh.h b/code/AssetLib/Blender/BlenderBMesh.h
similarity index 100%
rename from code/Blender/BlenderBMesh.h
rename to code/AssetLib/Blender/BlenderBMesh.h
diff --git a/code/AssetLib/Blender/BlenderCustomData.cpp b/code/AssetLib/Blender/BlenderCustomData.cpp
new file mode 100644
index 000000000..c752da4e0
--- /dev/null
+++ b/code/AssetLib/Blender/BlenderCustomData.cpp
@@ -0,0 +1,181 @@
+#include "BlenderCustomData.h"
+#include "BlenderDNA.h"
+#include <array>
+#include <functional>
+
+namespace Assimp {
+namespace Blender {
+/**
+        *   @brief  read/convert of Structure array to memory
+        */
+template <typename T>
+bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) {
+    for (size_t i = 0; i < cnt; ++i) {
+        T read;
+        s.Convert(read, db);
+        *p = read;
+        p++;
+    }
+    return true;
+}
+
+/**
+        *   @brief  pointer to function read memory for n CustomData types
+        */
+typedef bool (*PRead)(ElemBase *pOut, const size_t cnt, const FileDatabase &db);
+typedef ElemBase *(*PCreate)(const size_t cnt);
+typedef void (*PDestroy)(ElemBase *);
+
+#define IMPL_STRUCT_READ(ty)                                               \
+    bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) { \
+        ty *ptr = dynamic_cast<ty *>(v);                                   \
+        if (nullptr == ptr) {                                              \
+            return false;                                                  \
+        }                                                                  \
+        return read<ty>(db.dna[#ty], ptr, cnt, db);                        \
+    }
+
+#define IMPL_STRUCT_CREATE(ty)               \
+    ElemBase *create##ty(const size_t cnt) { \
+        return new ty[cnt];                  \
+    }
+
+#define IMPL_STRUCT_DESTROY(ty)         \
+    void destroy##ty(ElemBase *pE) {    \
+        ty *p = dynamic_cast<ty *>(pE); \
+        delete[] p;                     \
+    }
+
+/**
+        *   @brief  helper macro to define Structure functions
+        */
+#define IMPL_STRUCT(ty)    \
+    IMPL_STRUCT_READ(ty)   \
+    IMPL_STRUCT_CREATE(ty) \
+    IMPL_STRUCT_DESTROY(ty)
+
+// supported structures for CustomData
+IMPL_STRUCT(MVert)
+IMPL_STRUCT(MEdge)
+IMPL_STRUCT(MFace)
+IMPL_STRUCT(MTFace)
+IMPL_STRUCT(MTexPoly)
+IMPL_STRUCT(MLoopUV)
+IMPL_STRUCT(MLoopCol)
+IMPL_STRUCT(MPoly)
+IMPL_STRUCT(MLoop)
+
+/**
+        *   @brief  describes the size of data and the read function to be used for single CustomerData.type
+        */
+struct CustomDataTypeDescription {
+    PRead Read; ///< function to read one CustomData type element
+    PCreate Create; ///< function to allocate n type elements
+    PDestroy Destroy;
+
+    CustomDataTypeDescription(PRead read, PCreate create, PDestroy destroy) :
+            Read(read), Create(create), Destroy(destroy) {}
+};
+
+/**
+        *   @brief  helper macro to define Structure type specific CustomDataTypeDescription
+        *   @note   IMPL_STRUCT_READ for same ty must be used earlier to implement the typespecific read function
+        */
+#define DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(ty) \
+    CustomDataTypeDescription { &read##ty, &create##ty, &destroy##ty }
+
+/**
+        *   @brief  helper macro to define CustomDataTypeDescription for UNSUPPORTED type
+        */
+#define DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION \
+    CustomDataTypeDescription { nullptr, nullptr, nullptr }
+
+/**
+        *   @brief  descriptors for data pointed to from CustomDataLayer.data
+        *   @note   some of the CustomData uses already well defined Structures
+        *           other (like CD_ORCO, ...) uses arrays of rawtypes or even arrays of Structures
+        *           use a special readfunction for that cases
+        */
+std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions = { { DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MVert),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MEdge),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MFace),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTFace),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTexPoly),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopUV),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopCol),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MPoly),
+        DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoop),
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
+        DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION } };
+
+bool isValidCustomDataType(const int cdtype) {
+    return cdtype >= 0 && cdtype < CD_NUMTYPES;
+}
+
+bool readCustomData(std::shared_ptr<ElemBase> &out, const int cdtype, const size_t cnt, const FileDatabase &db) {
+    if (!isValidCustomDataType(cdtype)) {
+        throw Error((Formatter::format(), "CustomData.type ", cdtype, " out of index"));
+    }
+
+    const CustomDataTypeDescription cdtd = customDataTypeDescriptions[cdtype];
+    if (cdtd.Read && cdtd.Create && cdtd.Destroy && cnt > 0) {
+        // allocate cnt elements and parse them from file
+        out.reset(cdtd.Create(cnt), cdtd.Destroy);
+        return cdtd.Read(out.get(), cnt, db);
+    }
+    return false;
+}
+
+std::shared_ptr<CustomDataLayer> getCustomDataLayer(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) {
+    for (auto it = customdata.layers.begin(); it != customdata.layers.end(); ++it) {
+        if (it->get()->type == cdtype && name == it->get()->name) {
+            return *it;
+        }
+    }
+    return nullptr;
+}
+
+const ElemBase *getCustomDataLayerData(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) {
+    const std::shared_ptr<CustomDataLayer> pLayer = getCustomDataLayer(customdata, cdtype, name);
+    if (pLayer && pLayer->data) {
+        return pLayer->data.get();
+    }
+    return nullptr;
+}
+} // namespace Blender
+} // namespace Assimp
diff --git a/code/Blender/BlenderCustomData.h b/code/AssetLib/Blender/BlenderCustomData.h
similarity index 100%
rename from code/Blender/BlenderCustomData.h
rename to code/AssetLib/Blender/BlenderCustomData.h
diff --git a/code/Blender/BlenderDNA.cpp b/code/AssetLib/Blender/BlenderDNA.cpp
similarity index 73%
rename from code/Blender/BlenderDNA.cpp
rename to code/AssetLib/Blender/BlenderDNA.cpp
index 53fb84824..69f139ec5 100644
--- a/code/Blender/BlenderDNA.cpp
+++ b/code/AssetLib/Blender/BlenderDNA.cpp
@@ -45,25 +45,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    serialized set of data structures.
  */
 
-
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 #include "BlenderDNA.h"
 #include <assimp/StreamReader.h>
-#include <assimp/fast_atof.h>
 #include <assimp/TinyFormatter.h>
+#include <assimp/fast_atof.h>
 
 using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
-static bool match4(StreamReaderAny& stream, const char* string) {
-    ai_assert( nullptr != string );
+static bool match4(StreamReaderAny &stream, const char *string) {
+    ai_assert(nullptr != string);
     char tmp[4];
-    tmp[ 0 ] = ( stream ).GetI1();
-    tmp[ 1 ] = ( stream ).GetI1();
-    tmp[ 2 ] = ( stream ).GetI1();
-    tmp[ 3 ] = ( stream ).GetI1();
-    return (tmp[0]==string[0] && tmp[1]==string[1] && tmp[2]==string[2] && tmp[3]==string[3]);
+    tmp[0] = (stream).GetI1();
+    tmp[1] = (stream).GetI1();
+    tmp[2] = (stream).GetI1();
+    tmp[3] = (stream).GetI1();
+    return (tmp[0] == string[0] && tmp[1] == string[1] && tmp[2] == string[2] && tmp[3] == string[3]);
 }
 
 struct Type {
@@ -72,75 +71,76 @@ struct Type {
 };
 
 // ------------------------------------------------------------------------------------------------
-void DNAParser::Parse ()
-{
-    StreamReaderAny& stream = *db.reader.get();
-    DNA& dna = db.dna;
+void DNAParser::Parse() {
+    StreamReaderAny &stream = *db.reader.get();
+    DNA &dna = db.dna;
 
-    if(!match4(stream,"SDNA")) {
+    if (!match4(stream, "SDNA")) {
         throw DeadlyImportError("BlenderDNA: Expected SDNA chunk");
     }
 
     // name dictionary
-    if(!match4(stream,"NAME")) {
+    if (!match4(stream, "NAME")) {
         throw DeadlyImportError("BlenderDNA: Expected NAME field");
     }
 
-    std::vector<std::string> names (stream.GetI4());
-    for(std::string& s : names) {
+    std::vector<std::string> names(stream.GetI4());
+    for (std::string &s : names) {
         while (char c = stream.GetI1()) {
             s += c;
         }
     }
 
     // type dictionary
-    for (;stream.GetCurrentPos() & 0x3; stream.GetI1());
-    if(!match4(stream,"TYPE")) {
+    for (; stream.GetCurrentPos() & 0x3; stream.GetI1())
+        ;
+    if (!match4(stream, "TYPE")) {
         throw DeadlyImportError("BlenderDNA: Expected TYPE field");
     }
 
-    std::vector<Type> types (stream.GetI4());
-    for(Type& s : types) {
+    std::vector<Type> types(stream.GetI4());
+    for (Type &s : types) {
         while (char c = stream.GetI1()) {
             s.name += c;
         }
     }
 
     // type length dictionary
-    for (;stream.GetCurrentPos() & 0x3; stream.GetI1());
-    if(!match4(stream,"TLEN")) {
+    for (; stream.GetCurrentPos() & 0x3; stream.GetI1())
+        ;
+    if (!match4(stream, "TLEN")) {
         throw DeadlyImportError("BlenderDNA: Expected TLEN field");
     }
 
-    for(Type& s : types) {
+    for (Type &s : types) {
         s.size = stream.GetI2();
     }
 
     // structures dictionary
-    for (;stream.GetCurrentPos() & 0x3; stream.GetI1());
-    if(!match4(stream,"STRC")) {
+    for (; stream.GetCurrentPos() & 0x3; stream.GetI1())
+        ;
+    if (!match4(stream, "STRC")) {
         throw DeadlyImportError("BlenderDNA: Expected STRC field");
     }
 
     size_t end = stream.GetI4(), fields = 0;
 
     dna.structures.reserve(end);
-    for(size_t i = 0; i != end; ++i) {
+    for (size_t i = 0; i != end; ++i) {
 
         uint16_t n = stream.GetI2();
         if (n >= types.size()) {
             throw DeadlyImportError((format(),
-                "BlenderDNA: Invalid type index in structure name" ,n,
-                " (there are only ", types.size(), " entries)"
-            ));
+                    "BlenderDNA: Invalid type index in structure name", n,
+                    " (there are only ", types.size(), " entries)"));
         }
 
         // maintain separate indexes
         dna.indices[types[n].name] = dna.structures.size();
 
         dna.structures.push_back(Structure());
-        Structure& s = dna.structures.back();
-        s.name  = types[n].name;
+        Structure &s = dna.structures.back();
+        s.name = types[n].name;
         //s.index = dna.structures.size()-1;
 
         n = stream.GetI2();
@@ -152,12 +152,11 @@ void DNAParser::Parse ()
             uint16_t j = stream.GetI2();
             if (j >= types.size()) {
                 throw DeadlyImportError((format(),
-                    "BlenderDNA: Invalid type index in structure field ", j,
-                    " (there are only ", types.size(), " entries)"
-                ));
+                        "BlenderDNA: Invalid type index in structure field ", j,
+                        " (there are only ", types.size(), " entries)"));
             }
             s.fields.push_back(Field());
-            Field& f = s.fields.back();
+            Field &f = s.fields.back();
             f.offset = offset;
 
             f.type = types[j].name;
@@ -166,9 +165,8 @@ void DNAParser::Parse ()
             j = stream.GetI2();
             if (j >= names.size()) {
                 throw DeadlyImportError((format(),
-                    "BlenderDNA: Invalid name index in structure field ", j,
-                    " (there are only ", names.size(), " entries)"
-                ));
+                        "BlenderDNA: Invalid name index in structure field ", j,
+                        " (there are only ", names.size(), " entries)"));
             }
 
             f.name = names[j];
@@ -191,26 +189,25 @@ void DNAParser::Parse ()
                 const std::string::size_type rb = f.name.find('[');
                 if (rb == std::string::npos) {
                     throw DeadlyImportError((format(),
-                        "BlenderDNA: Encountered invalid array declaration ",
-                        f.name
-                    ));
+                            "BlenderDNA: Encountered invalid array declaration ",
+                            f.name));
                 }
 
                 f.flags |= FieldFlag_Array;
-                DNA::ExtractArraySize(f.name,f.array_sizes);
-                f.name = f.name.substr(0,rb);
+                DNA::ExtractArraySize(f.name, f.array_sizes);
+                f.name = f.name.substr(0, rb);
 
                 f.size *= f.array_sizes[0] * f.array_sizes[1];
             }
 
             // maintain separate indexes
-            s.indices[f.name] = s.fields.size()-1;
+            s.indices[f.name] = s.fields.size() - 1;
             offset += f.size;
         }
         s.size = offset;
     }
 
-    ASSIMP_LOG_DEBUG_F( "BlenderDNA: Got ", dna.structures.size()," structures with totally ",fields," fields");
+    ASSIMP_LOG_DEBUG_F("BlenderDNA: Got ", dna.structures.size(), " structures with totally ", fields, " fields");
 
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
     dna.DumpToFile();
@@ -220,13 +217,11 @@ void DNAParser::Parse ()
     dna.RegisterConverters();
 }
 
-
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
 
 #include <fstream>
 // ------------------------------------------------------------------------------------------------
-void DNA :: DumpToFile()
-{
+void DNA ::DumpToFile() {
     // we don't bother using the VFS here for this is only for debugging.
     // (and all your bases are belong to us).
 
@@ -235,12 +230,14 @@ void DNA :: DumpToFile()
         ASSIMP_LOG_ERROR("Could not dump dna to dna.txt");
         return;
     }
-    f << "Field format: type name offset size" << "\n";
-    f << "Structure format: name size" << "\n";
+    f << "Field format: type name offset size"
+      << "\n";
+    f << "Structure format: name size"
+      << "\n";
 
-    for(const Structure& s : structures) {
+    for (const Structure &s : structures) {
         f << s.name << " " << s.size << "\n\n";
-        for(const Field& ff : s.fields) {
+        for (const Field &ff : s.fields) {
             f << "\t" << ff.type << " " << ff.name << " " << ff.offset << " " << ff.size << "\n";
         }
         f << "\n";
@@ -252,11 +249,9 @@ void DNA :: DumpToFile()
 #endif
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ void  DNA :: ExtractArraySize(
-    const std::string& out,
-    size_t array_sizes[2]
-)
-{
+/*static*/ void DNA ::ExtractArraySize(
+        const std::string &out,
+        size_t array_sizes[2]) {
     array_sizes[0] = array_sizes[1] = 1;
     std::string::size_type pos = out.find('[');
     if (pos++ == std::string::npos) {
@@ -264,7 +259,7 @@ void DNA :: DumpToFile()
     }
     array_sizes[0] = strtoul10(&out[pos]);
 
-    pos = out.find('[',pos);
+    pos = out.find('[', pos);
     if (pos++ == std::string::npos) {
         return;
     }
@@ -272,36 +267,32 @@ void DNA :: DumpToFile()
 }
 
 // ------------------------------------------------------------------------------------------------
-std::shared_ptr< ElemBase > DNA :: ConvertBlobToStructure(
-    const Structure& structure,
-    const FileDatabase& db
-) const
-{
-    std::map<std::string, FactoryPair >::const_iterator it = converters.find(structure.name);
+std::shared_ptr<ElemBase> DNA ::ConvertBlobToStructure(
+        const Structure &structure,
+        const FileDatabase &db) const {
+    std::map<std::string, FactoryPair>::const_iterator it = converters.find(structure.name);
     if (it == converters.end()) {
-        return std::shared_ptr< ElemBase >();
+        return std::shared_ptr<ElemBase>();
     }
 
-    std::shared_ptr< ElemBase > ret = (structure.*((*it).second.first))();
-    (structure.*((*it).second.second))(ret,db);
+    std::shared_ptr<ElemBase> ret = (structure.*((*it).second.first))();
+    (structure.*((*it).second.second))(ret, db);
 
     return ret;
 }
 
 // ------------------------------------------------------------------------------------------------
-DNA::FactoryPair DNA :: GetBlobToStructureConverter(
-    const Structure& structure,
-    const FileDatabase& /*db*/
-) const
-{
-    std::map<std::string,  FactoryPair>::const_iterator it = converters.find(structure.name);
+DNA::FactoryPair DNA ::GetBlobToStructureConverter(
+        const Structure &structure,
+        const FileDatabase & /*db*/
+) const {
+    std::map<std::string, FactoryPair>::const_iterator it = converters.find(structure.name);
     return it == converters.end() ? FactoryPair() : (*it).second;
 }
 
 // basing on http://www.blender.org/development/architecture/notes-on-sdna/
 // ------------------------------------------------------------------------------------------------
-void DNA :: AddPrimitiveStructures()
-{
+void DNA ::AddPrimitiveStructures() {
     // NOTE: these are just dummies. Their presence enforces
     // Structure::Convert<target_type> to be called on these
     // empty structures. These converters are special
@@ -311,30 +302,27 @@ void DNA :: AddPrimitiveStructures()
     // in question.
 
     indices["int"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "int";
     structures.back().size = 4;
 
     indices["short"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "short";
     structures.back().size = 2;
 
-
     indices["char"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "char";
     structures.back().size = 1;
 
-
     indices["float"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "float";
     structures.back().size = 4;
 
-
     indices["double"] = structures.size();
-    structures.push_back( Structure() );
+    structures.push_back(Structure());
     structures.back().name = "double";
     structures.back().size = 8;
 
@@ -342,8 +330,7 @@ void DNA :: AddPrimitiveStructures()
 }
 
 // ------------------------------------------------------------------------------------------------
-void SectionParser :: Next()
-{
+void SectionParser ::Next() {
     stream.SetCurrentPos(current.start + current.size);
 
     const char tmp[] = {
@@ -352,7 +339,7 @@ void SectionParser :: Next()
         (const char)stream.GetI1(),
         (const char)stream.GetI1()
     };
-    current.id = std::string(tmp,tmp[3]?4:tmp[2]?3:tmp[1]?2:1);
+    current.id = std::string(tmp, tmp[3] ? 4 : tmp[2] ? 3 : tmp[1] ? 2 : 1);
 
     current.size = stream.GetI4();
     current.address.val = ptr64 ? stream.GetU8() : stream.GetU4();
@@ -370,6 +357,4 @@ void SectionParser :: Next()
 #endif
 }
 
-
-
 #endif
diff --git a/code/Blender/BlenderDNA.h b/code/AssetLib/Blender/BlenderDNA.h
similarity index 76%
rename from code/Blender/BlenderDNA.h
rename to code/AssetLib/Blender/BlenderDNA.h
index 16ce960e2..7e04bad19 100644
--- a/code/Blender/BlenderDNA.h
+++ b/code/AssetLib/Blender/BlenderDNA.h
@@ -49,26 +49,27 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/BaseImporter.h>
 #include <assimp/StreamReader.h>
-#include <assimp/DefaultLogger.hpp>
 #include <stdint.h>
-#include <memory>
+#include <assimp/DefaultLogger.hpp>
 #include <map>
+#include <memory>
 
 // enable verbose log output. really verbose, so be careful.
 #ifdef ASSIMP_BUILD_DEBUG
-#   define ASSIMP_BUILD_BLENDER_DEBUG
+#define ASSIMP_BUILD_BLENDER_DEBUG
 #endif
 
 // #define ASSIMP_BUILD_BLENDER_NO_STATS
 
-namespace Assimp    {
+namespace Assimp {
 
-template <bool,bool> class StreamReader;
-typedef StreamReader<true,true> StreamReaderAny;
+template <bool, bool>
+class StreamReader;
+typedef StreamReader<true, true> StreamReaderAny;
 
 namespace Blender {
 
-class  FileDatabase;
+class FileDatabase;
 struct FileBlockHead;
 
 template <template <typename> class TOUT>
@@ -82,8 +83,8 @@ class ObjectCache;
  *  ancestry. */
 // -------------------------------------------------------------------------------
 struct Error : DeadlyImportError {
-    Error (const std::string& s)
-    : DeadlyImportError(s) {
+    Error(const std::string &s) :
+            DeadlyImportError(s) {
         // empty
     }
 };
@@ -93,9 +94,8 @@ struct Error : DeadlyImportError {
  *  descendents. It serves as base class for all data structure fields. */
 // -------------------------------------------------------------------------------
 struct ElemBase {
-    ElemBase()
-    : dna_type(nullptr)
-    {
+    ElemBase() :
+            dna_type(nullptr) {
         // empty
     }
 
@@ -110,7 +110,7 @@ struct ElemBase {
      * data type is not static, i.e. a std::shared_ptr<ElemBase>
      * in the scene description would have its type resolved
      * at runtime, so this member is always set. */
-    const char* dna_type;
+    const char *dna_type;
 };
 
 // -------------------------------------------------------------------------------
@@ -120,8 +120,8 @@ struct ElemBase {
  *  they used to point to.*/
 // -------------------------------------------------------------------------------
 struct Pointer {
-    Pointer()
-    : val() {
+    Pointer() :
+            val() {
         // empty
     }
     uint64_t val;
@@ -131,8 +131,8 @@ struct Pointer {
 /** Represents a generic offset within a BLEND file */
 // -------------------------------------------------------------------------------
 struct FileOffset {
-    FileOffset()
-    : val() {
+    FileOffset() :
+            val() {
         // empty
     }
     uint64_t val;
@@ -154,7 +154,7 @@ public:
         resize(0);
     }
 
-    operator bool () const {
+    operator bool() const {
         return !empty();
     }
 };
@@ -164,7 +164,7 @@ public:
 // -------------------------------------------------------------------------------
 enum FieldFlags {
     FieldFlag_Pointer = 0x1,
-    FieldFlag_Array   = 0x2
+    FieldFlag_Array = 0x2
 };
 
 // -------------------------------------------------------------------------------
@@ -200,7 +200,7 @@ enum ErrorPolicy {
 };
 
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
-#   define ErrorPolicy_Igno ErrorPolicy_Warn
+#define ErrorPolicy_Igno ErrorPolicy_Warn
 #endif
 
 // -------------------------------------------------------------------------------
@@ -212,47 +212,42 @@ enum ErrorPolicy {
  *  meaningful contents. */
 // -------------------------------------------------------------------------------
 class Structure {
-    template <template <typename> class> friend class ObjectCache;
+    template <template <typename> class>
+    friend class ObjectCache;
 
 public:
-    Structure()
-    : cache_idx(static_cast<size_t>(-1) ){
+    Structure() :
+            cache_idx(static_cast<size_t>(-1)) {
         // empty
     }
 
-public:
-
     // publicly accessible members
     std::string name;
-    vector< Field > fields;
+    vector<Field> fields;
     std::map<std::string, size_t> indices;
 
     size_t size;
 
-public:
-
     // --------------------------------------------------------
     /** Access a field of the structure by its canonical name. The pointer version
      *  returns NULL on failure while the reference version raises an import error. */
-    inline const Field& operator [] (const std::string& ss) const;
-    inline const Field* Get (const std::string& ss) const;
+    inline const Field &operator[](const std::string &ss) const;
+    inline const Field *Get(const std::string &ss) const;
 
     // --------------------------------------------------------
     /** Access a field of the structure by its index */
-    inline const Field& operator [] (const size_t i) const;
+    inline const Field &operator[](const size_t i) const;
 
     // --------------------------------------------------------
-    inline bool operator== (const Structure& other) const {
+    inline bool operator==(const Structure &other) const {
         return name == other.name; // name is meant to be an unique identifier
     }
 
     // --------------------------------------------------------
-    inline bool operator!= (const Structure& other) const {
+    inline bool operator!=(const Structure &other) const {
         return name != other.name;
     }
 
-public:
-
     // --------------------------------------------------------
     /** Try to read an instance of the structure from the stream
      *  and attempt to convert to `T`. This is done by
@@ -260,54 +255,54 @@ public:
      *  a compiler complain is the result.
      *  @param dest Destination value to be written
      *  @param db File database, including input stream. */
-    template <typename T> void Convert (T& dest, const FileDatabase& db) const;
+    template <typename T>
+    void Convert(T &dest, const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // generic converter
     template <typename T>
-    void Convert(std::shared_ptr<ElemBase> in,const FileDatabase& db) const;
+    void Convert(std::shared_ptr<ElemBase> in, const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // generic allocator
-    template <typename T> std::shared_ptr<ElemBase> Allocate() const;
-
-
+    template <typename T>
+    std::shared_ptr<ElemBase> Allocate() const;
 
     // --------------------------------------------------------
     // field parsing for 1d arrays
     template <int error_policy, typename T, size_t M>
-    void ReadFieldArray(T (& out)[M], const char* name,
-        const FileDatabase& db) const;
+    void ReadFieldArray(T (&out)[M], const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // field parsing for 2d arrays
     template <int error_policy, typename T, size_t M, size_t N>
-    void ReadFieldArray2(T (& out)[M][N], const char* name,
-        const FileDatabase& db) const;
+    void ReadFieldArray2(T (&out)[M][N], const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // field parsing for pointer or dynamic array types
     // (std::shared_ptr)
     // The return value indicates whether the data was already cached.
     template <int error_policy, template <typename> class TOUT, typename T>
-    bool ReadFieldPtr(TOUT<T>& out, const char* name,
-        const FileDatabase& db,
-        bool non_recursive = false) const;
+    bool ReadFieldPtr(TOUT<T> &out, const char *name,
+            const FileDatabase &db,
+            bool non_recursive = false) const;
 
     // --------------------------------------------------------
     // field parsing for static arrays of pointer or dynamic
     // array types (std::shared_ptr[])
     // The return value indicates whether the data was already cached.
     template <int error_policy, template <typename> class TOUT, typename T, size_t N>
-    bool ReadFieldPtr(TOUT<T> (&out)[N], const char* name,
-        const FileDatabase& db) const;
+    bool ReadFieldPtr(TOUT<T> (&out)[N], const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     // field parsing for `normal` values
     // The return value indicates whether the data was already cached.
     template <int error_policy, typename T>
-    void ReadField(T& out, const char* name,
-        const FileDatabase& db) const;
+    void ReadField(T &out, const char *name,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     /**
@@ -318,7 +313,7 @@ public:
     *   @return true when read was successful
     */
     template <int error_policy, template <typename> class TOUT, typename T>
-    bool ReadFieldPtrVector(vector<TOUT<T>>&out, const char* name, const FileDatabase& db) const;
+    bool ReadFieldPtrVector(vector<TOUT<T>> &out, const char *name, const FileDatabase &db) const;
 
     /**
     *   @brief  parses raw customdata
@@ -329,40 +324,40 @@ public:
     *   @return true when read was successful
     */
     template <int error_policy>
-    bool ReadCustomDataPtr(std::shared_ptr<ElemBase>&out, int cdtype, const char* name, const FileDatabase& db) const;
+    bool ReadCustomDataPtr(std::shared_ptr<ElemBase> &out, int cdtype, const char *name, const FileDatabase &db) const;
 
 private:
+    // --------------------------------------------------------
+    template <template <typename> class TOUT, typename T>
+    bool ResolvePointer(TOUT<T> &out, const Pointer &ptrval,
+            const FileDatabase &db, const Field &f,
+            bool non_recursive = false) const;
 
     // --------------------------------------------------------
     template <template <typename> class TOUT, typename T>
-    bool ResolvePointer(TOUT<T>& out, const Pointer & ptrval,
-        const FileDatabase& db, const Field& f,
-        bool non_recursive = false) const;
+    bool ResolvePointer(vector<TOUT<T>> &out, const Pointer &ptrval,
+            const FileDatabase &db, const Field &f, bool) const;
 
     // --------------------------------------------------------
-    template <template <typename> class TOUT, typename T>
-    bool ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval,
-        const FileDatabase& db, const Field& f, bool) const;
+    bool ResolvePointer(std::shared_ptr<FileOffset> &out, const Pointer &ptrval,
+            const FileDatabase &db, const Field &f, bool) const;
 
     // --------------------------------------------------------
-    bool ResolvePointer( std::shared_ptr< FileOffset >& out, const Pointer & ptrval,
-        const FileDatabase& db, const Field& f, bool) const;
-
-    // --------------------------------------------------------
-    inline const FileBlockHead* LocateFileBlockForAddress(
-        const Pointer & ptrval,
-        const FileDatabase& db) const;
+    inline const FileBlockHead *LocateFileBlockForAddress(
+            const Pointer &ptrval,
+            const FileDatabase &db) const;
 
 private:
-
     // ------------------------------------------------------------------------------
-    template <typename T> T* _allocate(std::shared_ptr<T>& out, size_t& s) const {
+    template <typename T>
+    T *_allocate(std::shared_ptr<T> &out, size_t &s) const {
         out = std::shared_ptr<T>(new T());
         s = 1;
         return out.get();
     }
 
-    template <typename T> T* _allocate(vector<T>& out, size_t& s) const {
+    template <typename T>
+    T *_allocate(vector<T> &out, size_t &s) const {
         out.resize(s);
         return s ? &out.front() : NULL;
     }
@@ -372,14 +367,14 @@ private:
     struct _defaultInitializer {
 
         template <typename T, unsigned int N>
-        void operator ()(T (& out)[N], const char* = NULL) {
+        void operator()(T (&out)[N], const char * = NULL) {
             for (unsigned int i = 0; i < N; ++i) {
                 out[i] = T();
             }
         }
 
         template <typename T, unsigned int N, unsigned int M>
-        void operator ()(T (& out)[N][M], const char* = NULL) {
+        void operator()(T (&out)[N][M], const char * = NULL) {
             for (unsigned int i = 0; i < N; ++i) {
                 for (unsigned int j = 0; j < M; ++j) {
                     out[i][j] = T();
@@ -388,21 +383,21 @@ private:
         }
 
         template <typename T>
-        void operator ()(T& out, const char* = NULL) {
+        void operator()(T &out, const char * = NULL) {
             out = T();
         }
     };
 
 private:
-
     mutable size_t cache_idx;
 };
 
 // --------------------------------------------------------
-template <>  struct Structure :: _defaultInitializer<ErrorPolicy_Warn> {
+template <>
+struct Structure ::_defaultInitializer<ErrorPolicy_Warn> {
 
     template <typename T>
-    void operator ()(T& out, const char* reason = "<add reason>") {
+    void operator()(T &out, const char *reason = "<add reason>") {
         ASSIMP_LOG_WARN(reason);
 
         // ... and let the show go on
@@ -410,10 +405,11 @@ template <>  struct Structure :: _defaultInitializer<ErrorPolicy_Warn> {
     }
 };
 
-template <> struct Structure :: _defaultInitializer<ErrorPolicy_Fail> {
+template <>
+struct Structure ::_defaultInitializer<ErrorPolicy_Fail> {
 
     template <typename T>
-    void operator ()(T& /*out*/,const char* = "") {
+    void operator()(T & /*out*/, const char * = "") {
         // obviously, it is crucial that _DefaultInitializer is used
         // only from within a catch clause.
         throw DeadlyImportError("Constructing BlenderDNA Structure encountered an error");
@@ -421,13 +417,12 @@ template <> struct Structure :: _defaultInitializer<ErrorPolicy_Fail> {
 };
 
 // -------------------------------------------------------------------------------------------------------
-template <> inline bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(std::shared_ptr<ElemBase>& out,
-    const Pointer & ptrval,
-    const FileDatabase& db,
-    const Field& f,
-    bool
-    ) const;
-
+template <>
+inline bool Structure ::ResolvePointer<std::shared_ptr, ElemBase>(std::shared_ptr<ElemBase> &out,
+        const Pointer &ptrval,
+        const FileDatabase &db,
+        const Field &f,
+        bool) const;
 
 // -------------------------------------------------------------------------------
 /** Represents the full data structure information for a single BLEND file.
@@ -435,40 +430,34 @@ template <> inline bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(st
  *  #DNAParser does the reading and represents currently the only place where
  *  DNA is altered.*/
 // -------------------------------------------------------------------------------
-class DNA
-{
+class DNA {
 public:
-
-    typedef void (Structure::*ConvertProcPtr) (
-        std::shared_ptr<ElemBase> in,
-        const FileDatabase&
-    ) const;
+    typedef void (Structure::*ConvertProcPtr)(
+            std::shared_ptr<ElemBase> in,
+            const FileDatabase &) const;
 
     typedef std::shared_ptr<ElemBase> (
-        Structure::*AllocProcPtr) () const;
+            Structure::*AllocProcPtr)() const;
 
-    typedef std::pair< AllocProcPtr, ConvertProcPtr > FactoryPair;
+    typedef std::pair<AllocProcPtr, ConvertProcPtr> FactoryPair;
 
 public:
-
-    std::map<std::string, FactoryPair > converters;
-    vector<Structure > structures;
+    std::map<std::string, FactoryPair> converters;
+    vector<Structure> structures;
     std::map<std::string, size_t> indices;
 
 public:
-
     // --------------------------------------------------------
     /** Access a structure by its canonical name, the pointer version returns NULL on failure
       * while the reference version raises an error. */
-    inline const Structure& operator [] (const std::string& ss) const;
-    inline const Structure* Get (const std::string& ss) const;
+    inline const Structure &operator[](const std::string &ss) const;
+    inline const Structure *Get(const std::string &ss) const;
 
     // --------------------------------------------------------
     /** Access a structure by its index */
-    inline const Structure& operator [] (const size_t i) const;
+    inline const Structure &operator[](const size_t i) const;
 
 public:
-
     // --------------------------------------------------------
     /** Add structure definitions for all the primitive types,
      *  i.e. integer, short, char, float */
@@ -483,7 +472,6 @@ public:
      *  known at compile time (consier Object::data).*/
     void RegisterConverters();
 
-
     // --------------------------------------------------------
     /** Take an input blob from the stream, interpret it according to
      *  a its structure name and convert it to the intermediate
@@ -491,10 +479,9 @@ public:
      *  @param structure Destination structure definition
      *  @param db File database.
      *  @return A null pointer if no appropriate converter is available.*/
-    std::shared_ptr< ElemBase > ConvertBlobToStructure(
-        const Structure& structure,
-        const FileDatabase& db
-        ) const;
+    std::shared_ptr<ElemBase> ConvertBlobToStructure(
+            const Structure &structure,
+            const FileDatabase &db) const;
 
     // --------------------------------------------------------
     /** Find a suitable conversion function for a given Structure.
@@ -505,10 +492,8 @@ public:
      *  @param db File database.
      *  @return A null pointer in .first if no appropriate converter is available.*/
     FactoryPair GetBlobToStructureConverter(
-        const Structure& structure,
-        const FileDatabase& db
-        ) const;
-
+            const Structure &structure,
+            const FileDatabase &db) const;
 
 #ifdef ASSIMP_BUILD_BLENDER_DEBUG
     // --------------------------------------------------------
@@ -527,25 +512,29 @@ public:
      *  @throw DeadlyImportError if more than 2 dimensions are
      *    encountered. */
     static void ExtractArraySize(
-        const std::string& out,
-        size_t array_sizes[2]
-    );
+            const std::string &out,
+            size_t array_sizes[2]);
 };
 
 // special converters for primitive types
-template <> inline void Structure :: Convert<int>       (int& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<short>     (short& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<char>      (char& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<float>     (float& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<double>    (double& dest,const FileDatabase& db) const;
-template <> inline void Structure :: Convert<Pointer>   (Pointer& dest,const FileDatabase& db) const;
+template <>
+inline void Structure ::Convert<int>(int &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<short>(short &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<char>(char &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<float>(float &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<double>(double &dest, const FileDatabase &db) const;
+template <>
+inline void Structure ::Convert<Pointer>(Pointer &dest, const FileDatabase &db) const;
 
 // -------------------------------------------------------------------------------
 /** Describes a master file block header. Each master file sections holds n
  *  elements of a certain SDNA structure (or otherwise unspecified data). */
 // -------------------------------------------------------------------------------
-struct FileBlockHead
-{
+struct FileBlockHead {
     // points right after the header of the file block
     StreamReaderAny::pos start;
 
@@ -561,66 +550,55 @@ struct FileBlockHead
     // number of structure instances to follow
     size_t num;
 
-
-
     // file blocks are sorted by address to quickly locate specific memory addresses
-    bool operator < (const FileBlockHead& o) const {
+    bool operator<(const FileBlockHead &o) const {
         return address.val < o.address.val;
     }
 
     // for std::upper_bound
-    operator const Pointer& () const {
+    operator const Pointer &() const {
         return address;
     }
 };
 
 // for std::upper_bound
-inline bool operator< (const Pointer& a, const Pointer& b) {
+inline bool operator<(const Pointer &a, const Pointer &b) {
     return a.val < b.val;
 }
 
 // -------------------------------------------------------------------------------
 /** Utility to read all master file blocks in turn. */
 // -------------------------------------------------------------------------------
-class SectionParser
-{
+class SectionParser {
 public:
-
     // --------------------------------------------------------
     /** @param stream Inout stream, must point to the
      *  first section in the file. Call Next() once
      *  to have it read.
      *  @param ptr64 Pointer size in file is 64 bits? */
-    SectionParser(StreamReaderAny& stream,bool ptr64)
-        : stream(stream)
-        , ptr64(ptr64)
-    {
+    SectionParser(StreamReaderAny &stream, bool ptr64) :
+            stream(stream), ptr64(ptr64) {
         current.size = current.start = 0;
     }
 
 public:
-
     // --------------------------------------------------------
-    const FileBlockHead& GetCurrent() const {
+    const FileBlockHead &GetCurrent() const {
         return current;
     }
 
-
 public:
-
     // --------------------------------------------------------
     /** Advance to the next section.
      *  @throw DeadlyImportError if the last chunk was passed. */
     void Next();
 
 public:
-
     FileBlockHead current;
-    StreamReaderAny& stream;
+    StreamReaderAny &stream;
     bool ptr64;
 };
 
-
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
 // -------------------------------------------------------------------------------
 /** Import statistics, i.e. number of file blocks read*/
@@ -628,17 +606,13 @@ public:
 class Statistics {
 
 public:
-
-    Statistics ()
-        : fields_read       ()
-        , pointers_resolved ()
-        , cache_hits        ()
-//      , blocks_read       ()
-        , cached_objects    ()
-    {}
+    Statistics() :
+            fields_read(), pointers_resolved(), cache_hits()
+            //      , blocks_read       ()
+            ,
+            cached_objects() {}
 
 public:
-
     /** total number of fields we read */
     unsigned int fields_read;
 
@@ -662,17 +636,13 @@ public:
  *  avoids circular references and avoids object duplication. */
 // -------------------------------------------------------------------------------
 template <template <typename> class TOUT>
-class ObjectCache
-{
+class ObjectCache {
 public:
-
-    typedef std::map< Pointer, TOUT<ElemBase> > StructureCache;
+    typedef std::map<Pointer, TOUT<ElemBase>> StructureCache;
 
 public:
-
-    ObjectCache(const FileDatabase& db)
-        : db(db)
-    {
+    ObjectCache(const FileDatabase &db) :
+            db(db) {
         // currently there are only ~400 structure records per blend file.
         // we read only a small part of them and don't cache objects
         // which we don't need, so this should suffice.
@@ -680,17 +650,17 @@ public:
     }
 
 public:
-
     // --------------------------------------------------------
     /** Check whether a specific item is in the cache.
      *  @param s Data type of the item
      *  @param out Output pointer. Unchanged if the
      *   cache doesn't know the item yet.
      *  @param ptr Item address to look for. */
-    template <typename T> void get (
-        const Structure& s,
-        TOUT<T>& out,
-        const Pointer& ptr) const;
+    template <typename T>
+    void get(
+            const Structure &s,
+            TOUT<T> &out,
+            const Pointer &ptr) const;
 
     // --------------------------------------------------------
     /** Add an item to the cache after the item has
@@ -700,47 +670,44 @@ public:
      *  @param s Data type of the item
      *  @param out Item to insert into the cache
      *  @param ptr address (cache key) of the item. */
-    template <typename T> void set
-        (const Structure& s,
-        const TOUT<T>& out,
-        const Pointer& ptr);
+    template <typename T>
+    void set(const Structure &s,
+            const TOUT<T> &out,
+            const Pointer &ptr);
 
 private:
-
     mutable vector<StructureCache> caches;
-    const FileDatabase& db;
+    const FileDatabase &db;
 };
 
 // -------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------
-template <> class ObjectCache<Blender::vector>
-{
+template <>
+class ObjectCache<Blender::vector> {
 public:
+    ObjectCache(const FileDatabase &) {}
 
-    ObjectCache(const FileDatabase&) {}
-
-    template <typename T> void get(const Structure&, vector<T>&, const Pointer&) {}
-    template <typename T> void set(const Structure&, const vector<T>&, const Pointer&) {}
+    template <typename T>
+    void get(const Structure &, vector<T> &, const Pointer &) {}
+    template <typename T>
+    void set(const Structure &, const vector<T> &, const Pointer &) {}
 };
 
 #ifdef _MSC_VER
-#   pragma warning(disable:4355)
+#pragma warning(disable : 4355)
 #endif
 
 // -------------------------------------------------------------------------------
 /** Memory representation of a full BLEND file and all its dependencies. The
  *  output aiScene is constructed from an instance of this data structure. */
 // -------------------------------------------------------------------------------
-class FileDatabase
-{
-    template <template <typename> class TOUT> friend class ObjectCache;
+class FileDatabase {
+    template <template <typename> class TOUT>
+    friend class ObjectCache;
 
 public:
-    FileDatabase()
-        : _cacheArrays(*this)
-        , _cache(*this)
-        , next_cache_idx()
-    {}
+    FileDatabase() :
+            _cacheArrays(*this), _cache(*this), next_cache_idx() {}
 
 public:
     // publicly accessible fields
@@ -748,12 +715,11 @@ public:
     bool little;
 
     DNA dna;
-    std::shared_ptr< StreamReaderAny > reader;
-    vector< FileBlockHead > entries;
+    std::shared_ptr<StreamReaderAny> reader;
+    vector<FileBlockHead> entries;
 
 public:
-
-    Statistics& stats() const {
+    Statistics &stats() const {
         return _stats;
     }
 
@@ -762,18 +728,16 @@ public:
     // arrays of objects are never cached because we can't easily
     // ensure their proper destruction.
     template <typename T>
-    ObjectCache<std::shared_ptr>& cache(std::shared_ptr<T>& /*in*/) const {
+    ObjectCache<std::shared_ptr> &cache(std::shared_ptr<T> & /*in*/) const {
         return _cache;
     }
 
     template <typename T>
-    ObjectCache<vector>& cache(vector<T>& /*in*/) const {
+    ObjectCache<vector> &cache(vector<T> & /*in*/) const {
         return _cacheArrays;
     }
 
 private:
-
-
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
     mutable Statistics _stats;
 #endif
@@ -785,24 +749,20 @@ private:
 };
 
 #ifdef _MSC_VER
-#   pragma warning(default:4355)
+#pragma warning(default : 4355)
 #endif
 
 // -------------------------------------------------------------------------------
 /** Factory to extract a #DNA from the DNA1 file block in a BLEND file. */
 // -------------------------------------------------------------------------------
-class DNAParser
-{
+class DNAParser {
 
 public:
-
     /** Bind the parser to a empty DNA and an input stream */
-    DNAParser(FileDatabase& db)
-        : db(db)
-    {}
+    DNAParser(FileDatabase &db) :
+            db(db) {}
 
 public:
-
     // --------------------------------------------------------
     /** Locate the DNA in the file and parse it. The input
      *  stream is expected to point to the beginning of the DN1
@@ -811,18 +771,16 @@ public:
      *  @throw DeadlyImportError if the DNA cannot be read.
      *  @note The position of the stream pointer is undefined
      *    afterwards.*/
-    void Parse ();
+    void Parse();
 
 public:
-
     /** Obtain a reference to the extracted DNA information */
-    const Blender::DNA& GetDNA() const {
+    const Blender::DNA &GetDNA() const {
         return db.dna;
     }
 
 private:
-
-    FileDatabase& db;
+    FileDatabase &db;
 };
 
 /**
@@ -835,9 +793,8 @@ private:
 */
 bool readCustomData(std::shared_ptr<ElemBase> &out, int cdtype, size_t cnt, const FileDatabase &db);
 
-
-    } // end Blend
-} // end Assimp
+} // namespace Blender
+} // namespace Assimp
 
 #include "BlenderDNA.inl"
 
diff --git a/code/Blender/BlenderDNA.inl b/code/AssetLib/Blender/BlenderDNA.inl
similarity index 99%
rename from code/Blender/BlenderDNA.inl
rename to code/AssetLib/Blender/BlenderDNA.inl
index fd9993008..a41ceab7f 100644
--- a/code/Blender/BlenderDNA.inl
+++ b/code/AssetLib/Blender/BlenderDNA.inl
@@ -795,7 +795,7 @@ const Structure& DNA :: operator [] (const std::string& ss) const
 const Structure* DNA :: Get (const std::string& ss) const
 {
     std::map<std::string, size_t>::const_iterator it = indices.find(ss);
-    return it == indices.end() ? NULL : &structures[(*it).second];
+    return it == indices.end() ? nullptr : &structures[(*it).second];
 }
 
 //--------------------------------------------------------------------------------
diff --git a/code/Blender/BlenderIntermediate.h b/code/AssetLib/Blender/BlenderIntermediate.h
similarity index 100%
rename from code/Blender/BlenderIntermediate.h
rename to code/AssetLib/Blender/BlenderIntermediate.h
diff --git a/code/Blender/BlenderLoader.cpp b/code/AssetLib/Blender/BlenderLoader.cpp
similarity index 100%
rename from code/Blender/BlenderLoader.cpp
rename to code/AssetLib/Blender/BlenderLoader.cpp
diff --git a/code/Blender/BlenderLoader.h b/code/AssetLib/Blender/BlenderLoader.h
similarity index 100%
rename from code/Blender/BlenderLoader.h
rename to code/AssetLib/Blender/BlenderLoader.h
diff --git a/code/Blender/BlenderModifier.cpp b/code/AssetLib/Blender/BlenderModifier.cpp
similarity index 94%
rename from code/Blender/BlenderModifier.cpp
rename to code/AssetLib/Blender/BlenderModifier.cpp
index 2d99fbbc9..12af2d8cc 100644
--- a/code/Blender/BlenderModifier.cpp
+++ b/code/AssetLib/Blender/BlenderModifier.cpp
@@ -68,7 +68,7 @@ static const fpCreateModifier creators[] = {
     &god<BlenderModifier_Mirror>,
     &god<BlenderModifier_Subdivision>,
 
-    NULL // sentinel
+    nullptr // sentinel
 };
 
 // ------------------------------------------------------------------------------------------------
@@ -127,7 +127,7 @@ void BlenderModifierShowcase::ApplyModifiers(aiNode &out, ConversionData &conv_d
                 modifier->DoIt(out, conv_data, *static_cast<const ElemBase *>(cur), in, orig_object);
                 cnt++;
 
-                curgod = NULL;
+                curgod = nullptr;
                 break;
             }
         }
@@ -229,7 +229,7 @@ void BlenderModifier_Mirror ::DoIt(aiNode &out, ConversionData &conv_data, const
 
         // Only reverse the winding order if an odd number of axes were mirrored.
         if (xs * ys * zs < 0) {
-            for (unsigned int j = 0; j < mesh->mNumFaces; ++j ) {
+            for (unsigned int j = 0; j < mesh->mNumFaces; ++j) {
                 aiFace &face = mesh->mFaces[j];
                 for (unsigned int fi = 0; fi < face.mNumIndices / 2; ++fi)
                     std::swap(face.mIndices[fi], face.mIndices[face.mNumIndices - 1 - fi]);
@@ -267,18 +267,18 @@ void BlenderModifier_Subdivision ::DoIt(aiNode &out, ConversionData &conv_data,
 
     Subdivider::Algorithm algo;
     switch (mir.subdivType) {
-        case SubsurfModifierData::TYPE_CatmullClarke:
-            algo = Subdivider::CATMULL_CLARKE;
-            break;
+    case SubsurfModifierData::TYPE_CatmullClarke:
+        algo = Subdivider::CATMULL_CLARKE;
+        break;
 
-        case SubsurfModifierData::TYPE_Simple:
-            ASSIMP_LOG_WARN("BlendModifier: The `SIMPLE` subdivision algorithm is not currently implemented, using Catmull-Clarke");
-            algo = Subdivider::CATMULL_CLARKE;
-            break;
+    case SubsurfModifierData::TYPE_Simple:
+        ASSIMP_LOG_WARN("BlendModifier: The `SIMPLE` subdivision algorithm is not currently implemented, using Catmull-Clarke");
+        algo = Subdivider::CATMULL_CLARKE;
+        break;
 
-        default:
-            ASSIMP_LOG_WARN_F("BlendModifier: Unrecognized subdivision algorithm: ", mir.subdivType);
-            return;
+    default:
+        ASSIMP_LOG_WARN_F("BlendModifier: Unrecognized subdivision algorithm: ", mir.subdivType);
+        return;
     };
 
     std::unique_ptr<Subdivider> subd(Subdivider::Create(algo));
diff --git a/code/Blender/BlenderModifier.h b/code/AssetLib/Blender/BlenderModifier.h
similarity index 100%
rename from code/Blender/BlenderModifier.h
rename to code/AssetLib/Blender/BlenderModifier.h
diff --git a/code/AssetLib/Blender/BlenderScene.cpp b/code/AssetLib/Blender/BlenderScene.cpp
new file mode 100644
index 000000000..c654b5b14
--- /dev/null
+++ b/code/AssetLib/Blender/BlenderScene.cpp
@@ -0,0 +1,838 @@
+/*
+Open Asset Import Library (ASSIMP)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, ASSIMP Development 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 Development 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  BlenderScene.cpp
+ *  @brief MACHINE GENERATED BY ./scripts/BlenderImporter/genblenddna.py
+ */
+
+#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
+
+#include "BlenderScene.h"
+#include "BlenderCustomData.h"
+#include "BlenderDNA.h"
+#include "BlenderSceneGen.h"
+
+using namespace Assimp;
+using namespace Assimp::Blender;
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Object>(
+        Object &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    int temp = 0;
+    ReadField<ErrorPolicy_Fail>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Object::Type>(temp);
+    ReadFieldArray2<ErrorPolicy_Warn>(dest.obmat, "obmat", db);
+    ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv, "parentinv", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr, "parsubstr", db);
+    {
+        std::shared_ptr<Object> parent;
+        ReadFieldPtr<ErrorPolicy_Warn>(parent, "*parent", db);
+        dest.parent = parent.get();
+    }
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.track, "*track", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy, "*proxy", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_from, "*proxy_from", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_group, "*proxy_group", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.dup_group, "*dup_group", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.data, "*data", db);
+    ReadField<ErrorPolicy_Igno>(dest.modifiers, "modifiers", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Group>(
+        Group &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Igno>(dest.layer, "layer", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.gobject, "*gobject", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MTex>(
+        MTex &dest,
+        const FileDatabase &db) const {
+
+    int temp_short = 0;
+    ReadField<ErrorPolicy_Igno>(temp_short, "mapto", db);
+    dest.mapto = static_cast<Assimp::Blender::MTex::MapType>(temp_short);
+    int temp = 0;
+    ReadField<ErrorPolicy_Igno>(temp, "blendtype", db);
+    dest.blendtype = static_cast<Assimp::Blender::MTex::BlendType>(temp);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.object, "*object", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.tex, "*tex", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.uvname, "uvname", db);
+    ReadField<ErrorPolicy_Igno>(temp, "projx", db);
+    dest.projx = static_cast<Assimp::Blender::MTex::Projection>(temp);
+    ReadField<ErrorPolicy_Igno>(temp, "projy", db);
+    dest.projy = static_cast<Assimp::Blender::MTex::Projection>(temp);
+    ReadField<ErrorPolicy_Igno>(temp, "projz", db);
+    dest.projz = static_cast<Assimp::Blender::MTex::Projection>(temp);
+    ReadField<ErrorPolicy_Igno>(dest.mapping, "mapping", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.ofs, "ofs", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.size, "size", db);
+    ReadField<ErrorPolicy_Igno>(dest.rot, "rot", db);
+    ReadField<ErrorPolicy_Igno>(dest.texflag, "texflag", db);
+    ReadField<ErrorPolicy_Igno>(dest.colormodel, "colormodel", db);
+    ReadField<ErrorPolicy_Igno>(dest.pmapto, "pmapto", db);
+    ReadField<ErrorPolicy_Igno>(dest.pmaptoneg, "pmaptoneg", db);
+    ReadField<ErrorPolicy_Warn>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Warn>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Warn>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Warn>(dest.k, "k", db);
+    ReadField<ErrorPolicy_Igno>(dest.colspecfac, "colspecfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirrfac, "mirrfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.alphafac, "alphafac", db);
+    ReadField<ErrorPolicy_Igno>(dest.difffac, "difffac", db);
+    ReadField<ErrorPolicy_Igno>(dest.specfac, "specfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.emitfac, "emitfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.hardfac, "hardfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.norfac, "norfac", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<TFace>(
+        TFace &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv, "uv", db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.col, "col", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.tile, "tile", db);
+    ReadField<ErrorPolicy_Igno>(dest.unwrap, "unwrap", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<SubsurfModifierData>(
+        SubsurfModifierData &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.modifier, "modifier", db);
+    ReadField<ErrorPolicy_Warn>(dest.subdivType, "subdivType", db);
+    ReadField<ErrorPolicy_Fail>(dest.levels, "levels", db);
+    ReadField<ErrorPolicy_Igno>(dest.renderLevels, "renderLevels", db);
+    ReadField<ErrorPolicy_Igno>(dest.flags, "flags", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MFace>(
+        MFace &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.v1, "v1", db);
+    ReadField<ErrorPolicy_Fail>(dest.v2, "v2", db);
+    ReadField<ErrorPolicy_Fail>(dest.v3, "v3", db);
+    ReadField<ErrorPolicy_Fail>(dest.v4, "v4", db);
+    ReadField<ErrorPolicy_Fail>(dest.mat_nr, "mat_nr", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Lamp>(
+        Lamp &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    int temp = 0;
+    ReadField<ErrorPolicy_Fail>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Lamp::Type>(temp);
+    ReadField<ErrorPolicy_Igno>(dest.flags, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.colormodel, "colormodel", db);
+    ReadField<ErrorPolicy_Igno>(dest.totex, "totex", db);
+    ReadField<ErrorPolicy_Warn>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Warn>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Warn>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Warn>(dest.k, "k", db);
+    ReadField<ErrorPolicy_Igno>(dest.energy, "energy", db);
+    ReadField<ErrorPolicy_Warn>(dest.dist, "dist", db);
+    ReadField<ErrorPolicy_Igno>(dest.spotsize, "spotsize", db);
+    ReadField<ErrorPolicy_Igno>(dest.spotblend, "spotblend", db);
+    ReadField<ErrorPolicy_Warn>(dest.constant_coefficient, "coeff_const", db);
+    ReadField<ErrorPolicy_Warn>(dest.linear_coefficient, "coeff_lin", db);
+    ReadField<ErrorPolicy_Warn>(dest.quadratic_coefficient, "coeff_quad", db);
+    ReadField<ErrorPolicy_Igno>(dest.att1, "att1", db);
+    ReadField<ErrorPolicy_Igno>(dest.att2, "att2", db);
+    ReadField<ErrorPolicy_Igno>(temp, "falloff_type", db);
+    dest.falloff_type = static_cast<Assimp::Blender::Lamp::FalloffType>(temp);
+    ReadField<ErrorPolicy_Igno>(dest.sun_brightness, "sun_brightness", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_size, "area_size", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_sizey, "area_sizey", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_sizez, "area_sizez", db);
+    ReadField<ErrorPolicy_Igno>(dest.area_shape, "area_shape", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MDeformWeight>(
+        MDeformWeight &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.def_nr, "def_nr", db);
+    ReadField<ErrorPolicy_Fail>(dest.weight, "weight", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<PackedFile>(
+        PackedFile &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Warn>(dest.size, "size", db);
+    ReadField<ErrorPolicy_Warn>(dest.seek, "seek", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.data, "*data", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Base>(
+        Base &dest,
+        const FileDatabase &db) const {
+    // note: as per https://github.com/assimp/assimp/issues/128,
+    // reading the Object linked list recursively is prone to stack overflow.
+    // This structure converter is therefore an hand-written exception that
+    // does it iteratively.
+
+    const int initial_pos = db.reader->GetCurrentPos();
+
+    std::pair<Base *, int> todo = std::make_pair(&dest, initial_pos);
+    for (;;) {
+
+        Base &cur_dest = *todo.first;
+        db.reader->SetCurrentPos(todo.second);
+
+        // we know that this is a double-linked, circular list which we never
+        // traverse backwards, so don't bother resolving the back links.
+        cur_dest.prev = nullptr;
+
+        ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.object, "*object", db);
+
+        // the return value of ReadFieldPtr indicates whether the object
+        // was already cached. In this case, we don't need to resolve
+        // it again.
+        if (!ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.next, "*next", db, true) && cur_dest.next) {
+            todo = std::make_pair(&*cur_dest.next, db.reader->GetCurrentPos());
+            continue;
+        }
+        break;
+    }
+
+    db.reader->SetCurrentPos(initial_pos + size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MTFace>(
+        MTFace &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv, "uv", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.tile, "tile", db);
+    ReadField<ErrorPolicy_Igno>(dest.unwrap, "unwrap", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Material>(
+        Material &dest,
+        const FileDatabase &db) const {
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Warn>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Warn>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Warn>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Warn>(dest.specr, "specr", db);
+    ReadField<ErrorPolicy_Warn>(dest.specg, "specg", db);
+    ReadField<ErrorPolicy_Warn>(dest.specb, "specb", db);
+    ReadField<ErrorPolicy_Igno>(dest.har, "har", db);
+    ReadField<ErrorPolicy_Warn>(dest.ambr, "ambr", db);
+    ReadField<ErrorPolicy_Warn>(dest.ambg, "ambg", db);
+    ReadField<ErrorPolicy_Warn>(dest.ambb, "ambb", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirr, "mirr", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirg, "mirg", db);
+    ReadField<ErrorPolicy_Igno>(dest.mirb, "mirb", db);
+    ReadField<ErrorPolicy_Warn>(dest.emit, "emit", db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_mirror, "ray_mirror", db);
+    ReadField<ErrorPolicy_Warn>(dest.alpha, "alpha", db);
+    ReadField<ErrorPolicy_Igno>(dest.ref, "ref", db);
+    ReadField<ErrorPolicy_Igno>(dest.translucency, "translucency", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.roughness, "roughness", db);
+    ReadField<ErrorPolicy_Igno>(dest.darkness, "darkness", db);
+    ReadField<ErrorPolicy_Igno>(dest.refrac, "refrac", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.group, "*group", db);
+    ReadField<ErrorPolicy_Warn>(dest.diff_shader, "diff_shader", db);
+    ReadField<ErrorPolicy_Warn>(dest.spec_shader, "spec_shader", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtex, "*mtex", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.amb, "amb", db);
+    ReadField<ErrorPolicy_Igno>(dest.ang, "ang", db);
+    ReadField<ErrorPolicy_Igno>(dest.spectra, "spectra", db);
+    ReadField<ErrorPolicy_Igno>(dest.spec, "spec", db);
+    ReadField<ErrorPolicy_Igno>(dest.zoffs, "zoffs", db);
+    ReadField<ErrorPolicy_Igno>(dest.add, "add", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir, "fresnel_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir_i, "fresnel_mir_i", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra, "fresnel_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra_i, "fresnel_tra_i", db);
+    ReadField<ErrorPolicy_Igno>(dest.filter, "filter", db);
+    ReadField<ErrorPolicy_Igno>(dest.tx_limit, "tx_limit", db);
+    ReadField<ErrorPolicy_Igno>(dest.tx_falloff, "tx_falloff", db);
+    ReadField<ErrorPolicy_Igno>(dest.gloss_mir, "gloss_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.gloss_tra, "gloss_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_mir, "adapt_thresh_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_tra, "adapt_thresh_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.aniso_gloss_mir, "aniso_gloss_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.dist_mir, "dist_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.hasize, "hasize", db);
+    ReadField<ErrorPolicy_Igno>(dest.flaresize, "flaresize", db);
+    ReadField<ErrorPolicy_Igno>(dest.subsize, "subsize", db);
+    ReadField<ErrorPolicy_Igno>(dest.flareboost, "flareboost", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_sta, "strand_sta", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_end, "strand_end", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_ease, "strand_ease", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_surfnor, "strand_surfnor", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_min, "strand_min", db);
+    ReadField<ErrorPolicy_Igno>(dest.strand_widthfade, "strand_widthfade", db);
+    ReadField<ErrorPolicy_Igno>(dest.sbias, "sbias", db);
+    ReadField<ErrorPolicy_Igno>(dest.lbias, "lbias", db);
+    ReadField<ErrorPolicy_Igno>(dest.shad_alpha, "shad_alpha", db);
+    ReadField<ErrorPolicy_Igno>(dest.param, "param", db);
+    ReadField<ErrorPolicy_Igno>(dest.rms, "rms", db);
+    ReadField<ErrorPolicy_Igno>(dest.rampfac_col, "rampfac_col", db);
+    ReadField<ErrorPolicy_Igno>(dest.rampfac_spec, "rampfac_spec", db);
+    ReadField<ErrorPolicy_Igno>(dest.friction, "friction", db);
+    ReadField<ErrorPolicy_Igno>(dest.fh, "fh", db);
+    ReadField<ErrorPolicy_Igno>(dest.reflect, "reflect", db);
+    ReadField<ErrorPolicy_Igno>(dest.fhdist, "fhdist", db);
+    ReadField<ErrorPolicy_Igno>(dest.xyfrict, "xyfrict", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_radius, "sss_radius", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_col, "sss_col", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_error, "sss_error", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_scale, "sss_scale", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_ior, "sss_ior", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_colfac, "sss_colfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_texfac, "sss_texfac", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_front, "sss_front", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_back, "sss_back", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.material_type, "material_type", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_depth, "ray_depth", db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_depth_tra, "ray_depth_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_mir, "samp_gloss_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_tra, "samp_gloss_tra", db);
+    ReadField<ErrorPolicy_Igno>(dest.fadeto_mir, "fadeto_mir", db);
+    ReadField<ErrorPolicy_Igno>(dest.shade_flag, "shade_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.flarec, "flarec", db);
+    ReadField<ErrorPolicy_Igno>(dest.starc, "starc", db);
+    ReadField<ErrorPolicy_Igno>(dest.linec, "linec", db);
+    ReadField<ErrorPolicy_Igno>(dest.ringc, "ringc", db);
+    ReadField<ErrorPolicy_Igno>(dest.pr_lamp, "pr_lamp", db);
+    ReadField<ErrorPolicy_Igno>(dest.pr_texture, "pr_texture", db);
+    ReadField<ErrorPolicy_Igno>(dest.ml_flag, "ml_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.diff_shader, "diff_shader", db);
+    ReadField<ErrorPolicy_Igno>(dest.spec_shader, "spec_shader", db);
+    ReadField<ErrorPolicy_Igno>(dest.texco, "texco", db);
+    ReadField<ErrorPolicy_Igno>(dest.mapto, "mapto", db);
+    ReadField<ErrorPolicy_Igno>(dest.ramp_show, "ramp_show", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad3, "pad3", db);
+    ReadField<ErrorPolicy_Igno>(dest.dynamode, "dynamode", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad2, "pad2", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_flag, "sss_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.sss_preset, "sss_preset", db);
+    ReadField<ErrorPolicy_Igno>(dest.shadowonly_flag, "shadowonly_flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.index, "index", db);
+    ReadField<ErrorPolicy_Igno>(dest.vcol_alpha, "vcol_alpha", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad4, "pad4", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.seed1, "seed1", db);
+    ReadField<ErrorPolicy_Igno>(dest.seed2, "seed2", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MTexPoly>(
+        MTexPoly &dest,
+        const FileDatabase &db) const {
+
+    {
+        std::shared_ptr<Image> tpage;
+        ReadFieldPtr<ErrorPolicy_Igno>(tpage, "*tpage", db);
+        dest.tpage = tpage.get();
+    }
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.transp, "transp", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadField<ErrorPolicy_Igno>(dest.tile, "tile", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad, "pad", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Mesh>(
+        Mesh &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadField<ErrorPolicy_Fail>(dest.totface, "totface", db);
+    ReadField<ErrorPolicy_Fail>(dest.totedge, "totedge", db);
+    ReadField<ErrorPolicy_Fail>(dest.totvert, "totvert", db);
+    ReadField<ErrorPolicy_Igno>(dest.totloop, "totloop", db);
+    ReadField<ErrorPolicy_Igno>(dest.totpoly, "totpoly", db);
+    ReadField<ErrorPolicy_Igno>(dest.subdiv, "subdiv", db);
+    ReadField<ErrorPolicy_Igno>(dest.subdivr, "subdivr", db);
+    ReadField<ErrorPolicy_Igno>(dest.subsurftype, "subsurftype", db);
+    ReadField<ErrorPolicy_Igno>(dest.smoothresh, "smoothresh", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mface, "*mface", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtface, "*mtface", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.tface, "*tface", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mvert, "*mvert", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.medge, "*medge", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloop, "*mloop", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopuv, "*mloopuv", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopcol, "*mloopcol", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mpoly, "*mpoly", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtpoly, "*mtpoly", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.dvert, "*dvert", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mcol, "*mcol", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.mat, "**mat", db);
+
+    ReadField<ErrorPolicy_Igno>(dest.vdata, "vdata", db);
+    ReadField<ErrorPolicy_Igno>(dest.edata, "edata", db);
+    ReadField<ErrorPolicy_Igno>(dest.fdata, "fdata", db);
+    ReadField<ErrorPolicy_Igno>(dest.pdata, "pdata", db);
+    ReadField<ErrorPolicy_Warn>(dest.ldata, "ldata", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MDeformVert>(
+        MDeformVert &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.dw, "*dw", db);
+    ReadField<ErrorPolicy_Igno>(dest.totweight, "totweight", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<World>(
+        World &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MLoopCol>(
+        MLoopCol &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Igno>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Igno>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Igno>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Igno>(dest.a, "a", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MVert>(
+        MVert &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray<ErrorPolicy_Fail>(dest.co, "co", db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.no, "no", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    //ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
+    ReadField<ErrorPolicy_Igno>(dest.bweight, "bweight", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MEdge>(
+        MEdge &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.v1, "v1", db);
+    ReadField<ErrorPolicy_Fail>(dest.v2, "v2", db);
+    ReadField<ErrorPolicy_Igno>(dest.crease, "crease", db);
+    ReadField<ErrorPolicy_Igno>(dest.bweight, "bweight", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MLoopUV>(
+        MLoopUV &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray<ErrorPolicy_Igno>(dest.uv, "uv", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<GroupObject>(
+        GroupObject &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.prev, "*prev", db);
+    ReadFieldPtr<ErrorPolicy_Fail>(dest.next, "*next", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.ob, "*ob", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<ListBase>(
+        ListBase &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.first, "*first", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.last, "*last", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MLoop>(
+        MLoop &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Igno>(dest.v, "v", db);
+    ReadField<ErrorPolicy_Igno>(dest.e, "e", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<ModifierData>(
+        ModifierData &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.next, "*next", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.prev, "*prev", db);
+    ReadField<ErrorPolicy_Igno>(dest.type, "type", db);
+    ReadField<ErrorPolicy_Igno>(dest.mode, "mode", db);
+    ReadFieldArray<ErrorPolicy_Igno>(dest.name, "name", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<ID>(
+        ID &dest,
+        const FileDatabase &db) const {
+
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MCol>(
+        MCol &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.r, "r", db);
+    ReadField<ErrorPolicy_Fail>(dest.g, "g", db);
+    ReadField<ErrorPolicy_Fail>(dest.b, "b", db);
+    ReadField<ErrorPolicy_Fail>(dest.a, "a", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MPoly>(
+        MPoly &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Igno>(dest.loopstart, "loopstart", db);
+    ReadField<ErrorPolicy_Igno>(dest.totloop, "totloop", db);
+    ReadField<ErrorPolicy_Igno>(dest.mat_nr, "mat_nr", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Scene>(
+        Scene &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.camera, "*camera", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.world, "*world", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.basact, "*basact", db);
+    ReadField<ErrorPolicy_Igno>(dest.base, "base", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Library>(
+        Library &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadFieldArray<ErrorPolicy_Fail>(dest.filename, "filename", db);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.parent, "*parent", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Tex>(
+        Tex &dest,
+        const FileDatabase &db) const {
+    short temp_short = 0;
+    ReadField<ErrorPolicy_Igno>(temp_short, "imaflag", db);
+    dest.imaflag = static_cast<Assimp::Blender::Tex::ImageFlags>(temp_short);
+    int temp = 0;
+    ReadField<ErrorPolicy_Fail>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Tex::Type>(temp);
+    ReadFieldPtr<ErrorPolicy_Warn>(dest.ima, "*ima", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Camera>(
+        Camera &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    int temp = 0;
+    ReadField<ErrorPolicy_Warn>(temp, "type", db);
+    dest.type = static_cast<Assimp::Blender::Camera::Type>(temp);
+    ReadField<ErrorPolicy_Warn>(temp, "flag", db);
+    dest.flag = static_cast<Assimp::Blender::Camera::Type>(temp);
+    ReadField<ErrorPolicy_Warn>(dest.lens, "lens", db);
+    ReadField<ErrorPolicy_Warn>(dest.sensor_x, "sensor_x", db);
+    ReadField<ErrorPolicy_Igno>(dest.clipsta, "clipsta", db);
+    ReadField<ErrorPolicy_Igno>(dest.clipend, "clipend", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<MirrorModifierData>(
+        MirrorModifierData &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.modifier, "modifier", db);
+    ReadField<ErrorPolicy_Igno>(dest.axis, "axis", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.tolerance, "tolerance", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.mirror_ob, "*mirror_ob", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure ::Convert<Image>(
+        Image &dest,
+        const FileDatabase &db) const {
+
+    ReadField<ErrorPolicy_Fail>(dest.id, "id", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadField<ErrorPolicy_Igno>(dest.ok, "ok", db);
+    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Igno>(dest.source, "source", db);
+    ReadField<ErrorPolicy_Igno>(dest.type, "type", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad, "pad", db);
+    ReadField<ErrorPolicy_Igno>(dest.pad1, "pad1", db);
+    ReadField<ErrorPolicy_Igno>(dest.lastframe, "lastframe", db);
+    ReadField<ErrorPolicy_Igno>(dest.tpageflag, "tpageflag", db);
+    ReadField<ErrorPolicy_Igno>(dest.totbind, "totbind", db);
+    ReadField<ErrorPolicy_Igno>(dest.xrep, "xrep", db);
+    ReadField<ErrorPolicy_Igno>(dest.yrep, "yrep", db);
+    ReadField<ErrorPolicy_Igno>(dest.twsta, "twsta", db);
+    ReadField<ErrorPolicy_Igno>(dest.twend, "twend", db);
+    ReadFieldPtr<ErrorPolicy_Igno>(dest.packedfile, "*packedfile", db);
+    ReadField<ErrorPolicy_Igno>(dest.lastupdate, "lastupdate", db);
+    ReadField<ErrorPolicy_Igno>(dest.lastused, "lastused", db);
+    ReadField<ErrorPolicy_Igno>(dest.animspeed, "animspeed", db);
+    ReadField<ErrorPolicy_Igno>(dest.gen_x, "gen_x", db);
+    ReadField<ErrorPolicy_Igno>(dest.gen_y, "gen_y", db);
+    ReadField<ErrorPolicy_Igno>(dest.gen_type, "gen_type", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<CustomData>(
+        CustomData &dest,
+        const FileDatabase &db) const {
+    ReadFieldArray<ErrorPolicy_Warn>(dest.typemap, "typemap", db);
+    ReadField<ErrorPolicy_Warn>(dest.totlayer, "totlayer", db);
+    ReadField<ErrorPolicy_Warn>(dest.maxlayer, "maxlayer", db);
+    ReadField<ErrorPolicy_Warn>(dest.totsize, "totsize", db);
+    ReadFieldPtrVector<ErrorPolicy_Warn>(dest.layers, "*layers", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+template <>
+void Structure::Convert<CustomDataLayer>(
+        CustomDataLayer &dest,
+        const FileDatabase &db) const {
+    ReadField<ErrorPolicy_Fail>(dest.type, "type", db);
+    ReadField<ErrorPolicy_Fail>(dest.offset, "offset", db);
+    ReadField<ErrorPolicy_Fail>(dest.flag, "flag", db);
+    ReadField<ErrorPolicy_Fail>(dest.active, "active", db);
+    ReadField<ErrorPolicy_Fail>(dest.active_rnd, "active_rnd", db);
+    ReadField<ErrorPolicy_Fail>(dest.active_clone, "active_clone", db);
+    ReadField<ErrorPolicy_Fail>(dest.active_mask, "active_mask", db);
+    ReadField<ErrorPolicy_Fail>(dest.uid, "uid", db);
+    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
+    ReadCustomDataPtr<ErrorPolicy_Fail>(dest.data, dest.type, "*data", db);
+
+    db.reader->IncPtr(size);
+}
+
+//--------------------------------------------------------------------------------
+void DNA::RegisterConverters() {
+
+    converters["Object"] = DNA::FactoryPair(&Structure::Allocate<Object>, &Structure::Convert<Object>);
+    converters["Group"] = DNA::FactoryPair(&Structure::Allocate<Group>, &Structure::Convert<Group>);
+    converters["MTex"] = DNA::FactoryPair(&Structure::Allocate<MTex>, &Structure::Convert<MTex>);
+    converters["TFace"] = DNA::FactoryPair(&Structure::Allocate<TFace>, &Structure::Convert<TFace>);
+    converters["SubsurfModifierData"] = DNA::FactoryPair(&Structure::Allocate<SubsurfModifierData>, &Structure::Convert<SubsurfModifierData>);
+    converters["MFace"] = DNA::FactoryPair(&Structure::Allocate<MFace>, &Structure::Convert<MFace>);
+    converters["Lamp"] = DNA::FactoryPair(&Structure::Allocate<Lamp>, &Structure::Convert<Lamp>);
+    converters["MDeformWeight"] = DNA::FactoryPair(&Structure::Allocate<MDeformWeight>, &Structure::Convert<MDeformWeight>);
+    converters["PackedFile"] = DNA::FactoryPair(&Structure::Allocate<PackedFile>, &Structure::Convert<PackedFile>);
+    converters["Base"] = DNA::FactoryPair(&Structure::Allocate<Base>, &Structure::Convert<Base>);
+    converters["MTFace"] = DNA::FactoryPair(&Structure::Allocate<MTFace>, &Structure::Convert<MTFace>);
+    converters["Material"] = DNA::FactoryPair(&Structure::Allocate<Material>, &Structure::Convert<Material>);
+    converters["MTexPoly"] = DNA::FactoryPair(&Structure::Allocate<MTexPoly>, &Structure::Convert<MTexPoly>);
+    converters["Mesh"] = DNA::FactoryPair(&Structure::Allocate<Mesh>, &Structure::Convert<Mesh>);
+    converters["MDeformVert"] = DNA::FactoryPair(&Structure::Allocate<MDeformVert>, &Structure::Convert<MDeformVert>);
+    converters["World"] = DNA::FactoryPair(&Structure::Allocate<World>, &Structure::Convert<World>);
+    converters["MLoopCol"] = DNA::FactoryPair(&Structure::Allocate<MLoopCol>, &Structure::Convert<MLoopCol>);
+    converters["MVert"] = DNA::FactoryPair(&Structure::Allocate<MVert>, &Structure::Convert<MVert>);
+    converters["MEdge"] = DNA::FactoryPair(&Structure::Allocate<MEdge>, &Structure::Convert<MEdge>);
+    converters["MLoopUV"] = DNA::FactoryPair(&Structure::Allocate<MLoopUV>, &Structure::Convert<MLoopUV>);
+    converters["GroupObject"] = DNA::FactoryPair(&Structure::Allocate<GroupObject>, &Structure::Convert<GroupObject>);
+    converters["ListBase"] = DNA::FactoryPair(&Structure::Allocate<ListBase>, &Structure::Convert<ListBase>);
+    converters["MLoop"] = DNA::FactoryPair(&Structure::Allocate<MLoop>, &Structure::Convert<MLoop>);
+    converters["ModifierData"] = DNA::FactoryPair(&Structure::Allocate<ModifierData>, &Structure::Convert<ModifierData>);
+    converters["ID"] = DNA::FactoryPair(&Structure::Allocate<ID>, &Structure::Convert<ID>);
+    converters["MCol"] = DNA::FactoryPair(&Structure::Allocate<MCol>, &Structure::Convert<MCol>);
+    converters["MPoly"] = DNA::FactoryPair(&Structure::Allocate<MPoly>, &Structure::Convert<MPoly>);
+    converters["Scene"] = DNA::FactoryPair(&Structure::Allocate<Scene>, &Structure::Convert<Scene>);
+    converters["Library"] = DNA::FactoryPair(&Structure::Allocate<Library>, &Structure::Convert<Library>);
+    converters["Tex"] = DNA::FactoryPair(&Structure::Allocate<Tex>, &Structure::Convert<Tex>);
+    converters["Camera"] = DNA::FactoryPair(&Structure::Allocate<Camera>, &Structure::Convert<Camera>);
+    converters["MirrorModifierData"] = DNA::FactoryPair(&Structure::Allocate<MirrorModifierData>, &Structure::Convert<MirrorModifierData>);
+    converters["Image"] = DNA::FactoryPair(&Structure::Allocate<Image>, &Structure::Convert<Image>);
+    converters["CustomData"] = DNA::FactoryPair(&Structure::Allocate<CustomData>, &Structure::Convert<CustomData>);
+    converters["CustomDataLayer"] = DNA::FactoryPair(&Structure::Allocate<CustomDataLayer>, &Structure::Convert<CustomDataLayer>);
+}
+
+#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
diff --git a/code/Blender/BlenderScene.h b/code/AssetLib/Blender/BlenderScene.h
similarity index 67%
rename from code/Blender/BlenderScene.h
rename to code/AssetLib/Blender/BlenderScene.h
index afa168d49..980dde6e0 100644
--- a/code/Blender/BlenderScene.h
+++ b/code/AssetLib/Blender/BlenderScene.h
@@ -48,14 +48,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BlenderDNA.h"
 
-namespace Assimp    {
+namespace Assimp {
 namespace Blender {
 
 // Minor parts of this file are extracts from blender data structures,
 // declared in the ./source/blender/makesdna directory.
 // Stuff that is not used by Assimp is commented.
 
-
 // NOTE
 // this file serves as input data to the `./scripts/genblenddna.py`
 // script. This script generates the actual binding code to read a
@@ -95,15 +94,15 @@ namespace Blender {
 
 // warn if field is missing, substitute default value
 #ifdef WARN
-#  undef WARN
+#undef WARN
 #endif
-#define WARN 
+#define WARN
 
 // fail the import if the field does not exist
 #ifdef FAIL
-#  undef FAIL
+#undef FAIL
 #endif
-#define FAIL 
+#define FAIL
 
 struct Object;
 struct MTex;
@@ -117,7 +116,7 @@ static const size_t MaxNameLen = 1024;
 
 // -------------------------------------------------------------------------------
 struct ID : ElemBase {
-    char name[ MaxNameLen ] WARN;
+    char name[MaxNameLen] WARN;
     short flag;
 };
 
@@ -127,17 +126,16 @@ struct ListBase : ElemBase {
     std::shared_ptr<ElemBase> last;
 };
 
-
 // -------------------------------------------------------------------------------
 struct PackedFile : ElemBase {
-     int size WARN;
-     int seek WARN;
-     std::shared_ptr< FileOffset > data WARN;
+    int size WARN;
+    int seek WARN;
+    std::shared_ptr<FileOffset> data WARN;
 };
 
 // -------------------------------------------------------------------------------
 struct GroupObject : ElemBase {
-    std::shared_ptr<GroupObject> prev,next FAIL;
+    std::shared_ptr<GroupObject> prev, next FAIL;
     std::shared_ptr<Object> ob;
 };
 
@@ -157,23 +155,20 @@ struct World : ElemBase {
 // -------------------------------------------------------------------------------
 struct MVert : ElemBase {
     float co[3] FAIL;
-    float no[3] FAIL;       // readed as short and divided through / 32767.f
+    float no[3] FAIL; // readed as short and divided through / 32767.f
     char flag;
     int mat_nr WARN;
     int bweight;
 
-    MVert() : ElemBase()
-        , flag(0)
-        , mat_nr(0)
-        , bweight(0)
-    {}
+    MVert() :
+            ElemBase(), flag(0), mat_nr(0), bweight(0) {}
 };
 
 // -------------------------------------------------------------------------------
 struct MEdge : ElemBase {
-      int v1, v2 FAIL;
-      char crease, bweight;
-      short flag;
+    int v1, v2 FAIL;
+    char crease, bweight;
+    short flag;
 };
 
 // -------------------------------------------------------------------------------
@@ -190,7 +185,7 @@ struct MLoopUV : ElemBase {
 // -------------------------------------------------------------------------------
 // Note that red and blue are not swapped, as with MCol
 struct MLoopCol : ElemBase {
-	unsigned char r, g, b, a;
+    unsigned char r, g, b, a;
 };
 
 // -------------------------------------------------------------------------------
@@ -203,19 +198,19 @@ struct MPoly : ElemBase {
 
 // -------------------------------------------------------------------------------
 struct MTexPoly : ElemBase {
-    Image* tpage;
+    Image *tpage;
     char flag, transp;
     short mode, tile, pad;
 };
 
 // -------------------------------------------------------------------------------
 struct MCol : ElemBase {
-    char r,g,b,a FAIL;
+    char r, g, b, a FAIL;
 };
 
 // -------------------------------------------------------------------------------
 struct MFace : ElemBase {
-    int v1,v2,v3,v4 FAIL;
+    int v1, v2, v3, v4 FAIL;
     int mat_nr FAIL;
     char flag;
 };
@@ -232,13 +227,9 @@ struct TFace : ElemBase {
 
 // -------------------------------------------------------------------------------
 struct MTFace : ElemBase {
-	MTFace()
-	: flag(0)
-	, mode(0)
-	, tile(0)
-	, unwrap(0)
-	{
-	}
+    MTFace() :
+            flag(0), mode(0), tile(0), unwrap(0) {
+    }
 
     float uv[4][2] FAIL;
     char flag;
@@ -250,31 +241,31 @@ struct MTFace : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct MDeformWeight : ElemBase  {
-      int    def_nr FAIL;
-      float  weight FAIL;
+struct MDeformWeight : ElemBase {
+    int def_nr FAIL;
+    float weight FAIL;
 };
 
 // -------------------------------------------------------------------------------
-struct MDeformVert : ElemBase  {
+struct MDeformVert : ElemBase {
     vector<MDeformWeight> dw WARN;
     int totweight;
 };
 
 // -------------------------------------------------------------------------------
-#define MA_RAYMIRROR    0x40000
+#define MA_RAYMIRROR 0x40000
 #define MA_TRANSPARENCY 0x10000
-#define MA_RAYTRANSP    0x20000
-#define MA_ZTRANSP      0x00040
+#define MA_RAYTRANSP 0x20000
+#define MA_ZTRANSP 0x00040
 
 struct Material : ElemBase {
     ID id FAIL;
 
-    float r,g,b WARN;
-    float specr,specg,specb WARN;
+    float r, g, b WARN;
+    float specr, specg, specb WARN;
     short har;
-    float ambr,ambg,ambb WARN;
-    float mirr,mirg,mirb;
+    float ambr, ambg, ambb WARN;
+    float mirr, mirg, mirb;
     float emit WARN;
     float ray_mirror;
     float alpha WARN;
@@ -399,20 +390,19 @@ struct CustomDataLayer : ElemBase {
     int active_mask;
     int uid;
     char name[64];
-    std::shared_ptr<ElemBase> data;     // must be converted to real type according type member
+    std::shared_ptr<ElemBase> data; // must be converted to real type according type member
 
-    CustomDataLayer()
-        : ElemBase()
-        , type(0)
-        , offset(0)
-        , flag(0)
-        , active(0)
-        , active_rnd(0)
-        , active_clone(0)
-        , active_mask(0)
-        , uid(0)
-        , data(nullptr)
-    {
+    CustomDataLayer() :
+            ElemBase(),
+            type(0),
+            offset(0),
+            flag(0),
+            active(0),
+            active_rnd(0),
+            active_clone(0),
+            active_mask(0),
+            uid(0),
+            data(nullptr) {
         memset(name, 0, sizeof name);
     }
 };
@@ -430,8 +420,8 @@ CustomData 208
     CustomDataExternal *external 200 8
 */
 struct CustomData : ElemBase {
-    vector<std::shared_ptr<struct CustomDataLayer> > layers;
-    int typemap[42];    // CD_NUMTYPES
+    vector<std::shared_ptr<struct CustomDataLayer>> layers;
+    int typemap[42]; // CD_NUMTYPES
     int totlayer;
     int maxlayer;
     int totsize;
@@ -469,7 +459,7 @@ struct Mesh : ElemBase {
     vector<MDeformVert> dvert;
     vector<MCol> mcol;
 
-    vector< std::shared_ptr<Material> > mat FAIL;
+    vector<std::shared_ptr<Material>> mat FAIL;
 
     struct CustomData vdata;
     struct CustomData edata;
@@ -490,142 +480,141 @@ struct Library : ElemBase {
 // -------------------------------------------------------------------------------
 struct Camera : ElemBase {
     enum Type {
-          Type_PERSP    =   0
-         ,Type_ORTHO    =   1
+        Type_PERSP = 0,
+        Type_ORTHO = 1
     };
 
     ID id FAIL;
 
-    Type type,flag WARN;
+    Type type, flag WARN;
     float lens WARN;
     float sensor_x WARN;
     float clipsta, clipend;
 };
 
-
 // -------------------------------------------------------------------------------
 struct Lamp : ElemBase {
 
     enum FalloffType {
-         FalloffType_Constant   = 0x0
-        ,FalloffType_InvLinear  = 0x1
-        ,FalloffType_InvSquare  = 0x2
+        FalloffType_Constant = 0x0,
+        FalloffType_InvLinear = 0x1,
+        FalloffType_InvSquare = 0x2
         //,FalloffType_Curve    = 0x3
         //,FalloffType_Sliders  = 0x4
     };
 
     enum Type {
-         Type_Local         = 0x0
-        ,Type_Sun           = 0x1
-        ,Type_Spot          = 0x2
-        ,Type_Hemi          = 0x3
-        ,Type_Area          = 0x4
+        Type_Local = 0x0,
+        Type_Sun = 0x1,
+        Type_Spot = 0x2,
+        Type_Hemi = 0x3,
+        Type_Area = 0x4
         //,Type_YFPhoton    = 0x5
     };
 
-      ID id FAIL;
-      //AnimData *adt;
+    ID id FAIL;
+    //AnimData *adt;
 
-      Type type FAIL;
-      short flags;
+    Type type FAIL;
+    short flags;
 
-      //int mode;
+    //int mode;
 
-      short colormodel, totex;
-      float r,g,b,k WARN;
-      //float shdwr, shdwg, shdwb;
+    short colormodel, totex;
+    float r, g, b, k WARN;
+    //float shdwr, shdwg, shdwb;
 
-      float energy, dist, spotsize, spotblend;
-      //float haint;
+    float energy, dist, spotsize, spotblend;
+    //float haint;
 
-      float constant_coefficient;
-      float linear_coefficient;
-      float quadratic_coefficient;
+    float constant_coefficient;
+    float linear_coefficient;
+    float quadratic_coefficient;
 
-      float att1, att2;
-      //struct CurveMapping *curfalloff;
-      FalloffType falloff_type;
+    float att1, att2;
+    //struct CurveMapping *curfalloff;
+    FalloffType falloff_type;
 
-      //float clipsta, clipend, shadspotsize;
-      //float bias, soft, compressthresh;
-      //short bufsize, samp, buffers, filtertype;
-      //char bufflag, buftype;
+    //float clipsta, clipend, shadspotsize;
+    //float bias, soft, compressthresh;
+    //short bufsize, samp, buffers, filtertype;
+    //char bufflag, buftype;
 
-      //short ray_samp, ray_sampy, ray_sampz;
-      //short ray_samp_type;
-      short area_shape;
-      float area_size, area_sizey, area_sizez;
-      //float adapt_thresh;
-      //short ray_samp_method;
+    //short ray_samp, ray_sampy, ray_sampz;
+    //short ray_samp_type;
+    short area_shape;
+    float area_size, area_sizey, area_sizez;
+    //float adapt_thresh;
+    //short ray_samp_method;
 
-      //short texact, shadhalostep;
+    //short texact, shadhalostep;
 
-      //short sun_effect_type;
-      //short skyblendtype;
-      //float horizon_brightness;
-      //float spread;
-      float sun_brightness;
-      //float sun_size;
-      //float backscattered_light;
-      //float sun_intensity;
-      //float atm_turbidity;
-      //float atm_inscattering_factor;
-      //float atm_extinction_factor;
-      //float atm_distance_factor;
-      //float skyblendfac;
-      //float sky_exposure;
-      //short sky_colorspace;
+    //short sun_effect_type;
+    //short skyblendtype;
+    //float horizon_brightness;
+    //float spread;
+    float sun_brightness;
+    //float sun_size;
+    //float backscattered_light;
+    //float sun_intensity;
+    //float atm_turbidity;
+    //float atm_inscattering_factor;
+    //float atm_extinction_factor;
+    //float atm_distance_factor;
+    //float skyblendfac;
+    //float sky_exposure;
+    //short sky_colorspace;
 
-      // int YF_numphotons, YF_numsearch;
-      // short YF_phdepth, YF_useqmc, YF_bufsize, YF_pad;
-      // float YF_causticblur, YF_ltradius;
+    // int YF_numphotons, YF_numsearch;
+    // short YF_phdepth, YF_useqmc, YF_bufsize, YF_pad;
+    // float YF_causticblur, YF_ltradius;
 
-      // float YF_glowint, YF_glowofs;
-      // short YF_glowtype, YF_pad2;
+    // float YF_glowint, YF_glowofs;
+    // short YF_glowtype, YF_pad2;
 
-      //struct Ipo *ipo;
-      //struct MTex *mtex[18];
-      // short pr_texture;
+    //struct Ipo *ipo;
+    //struct MTex *mtex[18];
+    // short pr_texture;
 
-      //struct PreviewImage *preview;
+    //struct PreviewImage *preview;
 };
 
 // -------------------------------------------------------------------------------
-struct ModifierData : ElemBase  {
+struct ModifierData : ElemBase {
     enum ModifierType {
-      eModifierType_None = 0,
-      eModifierType_Subsurf,
-      eModifierType_Lattice,
-      eModifierType_Curve,
-      eModifierType_Build,
-      eModifierType_Mirror,
-      eModifierType_Decimate,
-      eModifierType_Wave,
-      eModifierType_Armature,
-      eModifierType_Hook,
-      eModifierType_Softbody,
-      eModifierType_Boolean,
-      eModifierType_Array,
-      eModifierType_EdgeSplit,
-      eModifierType_Displace,
-      eModifierType_UVProject,
-      eModifierType_Smooth,
-      eModifierType_Cast,
-      eModifierType_MeshDeform,
-      eModifierType_ParticleSystem,
-      eModifierType_ParticleInstance,
-      eModifierType_Explode,
-      eModifierType_Cloth,
-      eModifierType_Collision,
-      eModifierType_Bevel,
-      eModifierType_Shrinkwrap,
-      eModifierType_Fluidsim,
-      eModifierType_Mask,
-      eModifierType_SimpleDeform,
-      eModifierType_Multires,
-      eModifierType_Surface,
-      eModifierType_Smoke,
-      eModifierType_ShapeKey
+        eModifierType_None = 0,
+        eModifierType_Subsurf,
+        eModifierType_Lattice,
+        eModifierType_Curve,
+        eModifierType_Build,
+        eModifierType_Mirror,
+        eModifierType_Decimate,
+        eModifierType_Wave,
+        eModifierType_Armature,
+        eModifierType_Hook,
+        eModifierType_Softbody,
+        eModifierType_Boolean,
+        eModifierType_Array,
+        eModifierType_EdgeSplit,
+        eModifierType_Displace,
+        eModifierType_UVProject,
+        eModifierType_Smooth,
+        eModifierType_Cast,
+        eModifierType_MeshDeform,
+        eModifierType_ParticleSystem,
+        eModifierType_ParticleInstance,
+        eModifierType_Explode,
+        eModifierType_Cloth,
+        eModifierType_Collision,
+        eModifierType_Bevel,
+        eModifierType_Shrinkwrap,
+        eModifierType_Fluidsim,
+        eModifierType_Mask,
+        eModifierType_SimpleDeform,
+        eModifierType_Multires,
+        eModifierType_Surface,
+        eModifierType_Smoke,
+        eModifierType_ShapeKey
     };
 
     std::shared_ptr<ElemBase> next WARN;
@@ -636,7 +625,7 @@ struct ModifierData : ElemBase  {
 };
 
 // -------------------------------------------------------------------------------
-struct SubsurfModifierData : ElemBase  {
+struct SubsurfModifierData : ElemBase {
 
     enum Type {
 
@@ -646,13 +635,13 @@ struct SubsurfModifierData : ElemBase  {
 
     enum Flags {
         // some omitted
-        FLAGS_SubsurfUV     =1<<3
+        FLAGS_SubsurfUV = 1 << 3
     };
 
     ModifierData modifier FAIL;
     short subdivType WARN;
     short levels FAIL;
-    short renderLevels ;
+    short renderLevels;
     short flags;
 };
 
@@ -660,13 +649,13 @@ struct SubsurfModifierData : ElemBase  {
 struct MirrorModifierData : ElemBase {
 
     enum Flags {
-        Flags_CLIPPING      =1<<0,
-        Flags_MIRROR_U      =1<<1,
-        Flags_MIRROR_V      =1<<2,
-        Flags_AXIS_X        =1<<3,
-        Flags_AXIS_Y        =1<<4,
-        Flags_AXIS_Z        =1<<5,
-        Flags_VGROUP        =1<<6
+        Flags_CLIPPING = 1 << 0,
+        Flags_MIRROR_U = 1 << 1,
+        Flags_MIRROR_V = 1 << 2,
+        Flags_AXIS_X = 1 << 3,
+        Flags_AXIS_Y = 1 << 4,
+        Flags_AXIS_Z = 1 << 5,
+        Flags_VGROUP = 1 << 6
     };
 
     ModifierData modifier FAIL;
@@ -677,22 +666,24 @@ struct MirrorModifierData : ElemBase {
 };
 
 // -------------------------------------------------------------------------------
-struct Object : ElemBase  {
+struct Object : ElemBase {
     ID id FAIL;
 
     enum Type {
-         Type_EMPTY     =   0
-        ,Type_MESH      =   1
-        ,Type_CURVE     =   2
-        ,Type_SURF      =   3
-        ,Type_FONT      =   4
-        ,Type_MBALL     =   5
+        Type_EMPTY = 0,
+        Type_MESH = 1,
+        Type_CURVE = 2,
+        Type_SURF = 3,
+        Type_FONT = 4,
+        Type_MBALL = 5
 
-        ,Type_LAMP      =   10
-        ,Type_CAMERA    =   11
+        ,
+        Type_LAMP = 10,
+        Type_CAMERA = 11
 
-        ,Type_WAVE      =   21
-        ,Type_LATTICE   =   22
+        ,
+        Type_WAVE = 21,
+        Type_LATTICE = 22
     };
 
     Type type FAIL;
@@ -700,39 +691,29 @@ struct Object : ElemBase  {
     float parentinv[4][4] WARN;
     char parsubstr[32] WARN;
 
-    Object* parent WARN;
+    Object *parent WARN;
     std::shared_ptr<Object> track WARN;
 
-    std::shared_ptr<Object> proxy,proxy_from,proxy_group WARN;
+    std::shared_ptr<Object> proxy, proxy_from, proxy_group WARN;
     std::shared_ptr<Group> dup_group WARN;
     std::shared_ptr<ElemBase> data FAIL;
 
     ListBase modifiers;
 
-    Object()
-    : ElemBase()
-    , type( Type_EMPTY )
-    , parent( nullptr )
-    , track()
-    , proxy()
-    , proxy_from()
-    , data() {
+    Object() :
+            ElemBase(), type(Type_EMPTY), parent(nullptr), track(), proxy(), proxy_from(), data() {
         // empty
     }
 };
 
-
 // -------------------------------------------------------------------------------
 struct Base : ElemBase {
-    Base* prev WARN;
+    Base *prev WARN;
     std::shared_ptr<Base> next WARN;
     std::shared_ptr<Object> object WARN;
 
-    Base() 
-    : ElemBase()
-    , prev( nullptr )
-    , next()
-    , object() {
+    Base() :
+            ElemBase(), prev(nullptr), next(), object() {
         // empty
         // empty
     }
@@ -748,11 +729,8 @@ struct Scene : ElemBase {
 
     ListBase base;
 
-    Scene()
-    : ElemBase()
-    , camera()
-    , world()
-    , basact() {
+    Scene() :
+            ElemBase(), camera(), world(), basact() {
         // empty
     }
 };
@@ -783,9 +761,9 @@ struct Image : ElemBase {
     short animspeed;
 
     short gen_x, gen_y, gen_type;
-    
-    Image()
-    : ElemBase() {
+
+    Image() :
+            ElemBase() {
         // empty
     }
 };
@@ -795,33 +773,33 @@ struct Tex : ElemBase {
 
     // actually, the only texture type we support is Type_IMAGE
     enum Type {
-         Type_CLOUDS        = 1
-        ,Type_WOOD          = 2
-        ,Type_MARBLE        = 3
-        ,Type_MAGIC         = 4
-        ,Type_BLEND         = 5
-        ,Type_STUCCI        = 6
-        ,Type_NOISE         = 7
-        ,Type_IMAGE         = 8
-        ,Type_PLUGIN        = 9
-        ,Type_ENVMAP        = 10
-        ,Type_MUSGRAVE      = 11
-        ,Type_VORONOI       = 12
-        ,Type_DISTNOISE     = 13
-        ,Type_POINTDENSITY  = 14
-        ,Type_VOXELDATA     = 15
+        Type_CLOUDS = 1,
+        Type_WOOD = 2,
+        Type_MARBLE = 3,
+        Type_MAGIC = 4,
+        Type_BLEND = 5,
+        Type_STUCCI = 6,
+        Type_NOISE = 7,
+        Type_IMAGE = 8,
+        Type_PLUGIN = 9,
+        Type_ENVMAP = 10,
+        Type_MUSGRAVE = 11,
+        Type_VORONOI = 12,
+        Type_DISTNOISE = 13,
+        Type_POINTDENSITY = 14,
+        Type_VOXELDATA = 15
     };
 
     enum ImageFlags {
-         ImageFlags_INTERPOL         = 1
-        ,ImageFlags_USEALPHA         = 2
-        ,ImageFlags_MIPMAP           = 4
-        ,ImageFlags_IMAROT           = 16
-        ,ImageFlags_CALCALPHA        = 32
-        ,ImageFlags_NORMALMAP        = 2048
-        ,ImageFlags_GAUSS_MIP        = 4096
-        ,ImageFlags_FILTER_MIN       = 8192
-        ,ImageFlags_DERIVATIVEMAP   = 16384
+        ImageFlags_INTERPOL = 1,
+        ImageFlags_USEALPHA = 2,
+        ImageFlags_MIPMAP = 4,
+        ImageFlags_IMAROT = 16,
+        ImageFlags_CALCALPHA = 32,
+        ImageFlags_NORMALMAP = 2048,
+        ImageFlags_GAUSS_MIP = 4096,
+        ImageFlags_FILTER_MIN = 8192,
+        ImageFlags_DERIVATIVEMAP = 16384
     };
 
     ID id FAIL;
@@ -876,11 +854,8 @@ struct Tex : ElemBase {
 
     //char use_nodes;
 
-    Tex()
-    : ElemBase()
-    , imaflag( ImageFlags_INTERPOL )
-    , type( Type_CLOUDS )
-    , ima() {
+    Tex() :
+            ElemBase(), imaflag(ImageFlags_INTERPOL), type(Type_CLOUDS), ima() {
         // empty
     }
 };
@@ -889,52 +864,52 @@ struct Tex : ElemBase {
 struct MTex : ElemBase {
 
     enum Projection {
-         Proj_N = 0
-        ,Proj_X = 1
-        ,Proj_Y = 2
-        ,Proj_Z = 3
+        Proj_N = 0,
+        Proj_X = 1,
+        Proj_Y = 2,
+        Proj_Z = 3
     };
 
     enum Flag {
-         Flag_RGBTOINT      = 0x1
-        ,Flag_STENCIL       = 0x2
-        ,Flag_NEGATIVE      = 0x4
-        ,Flag_ALPHAMIX      = 0x8
-        ,Flag_VIEWSPACE     = 0x10
+        Flag_RGBTOINT = 0x1,
+        Flag_STENCIL = 0x2,
+        Flag_NEGATIVE = 0x4,
+        Flag_ALPHAMIX = 0x8,
+        Flag_VIEWSPACE = 0x10
     };
 
     enum BlendType {
-         BlendType_BLEND            = 0
-        ,BlendType_MUL              = 1
-        ,BlendType_ADD              = 2
-        ,BlendType_SUB              = 3
-        ,BlendType_DIV              = 4
-        ,BlendType_DARK             = 5
-        ,BlendType_DIFF             = 6
-        ,BlendType_LIGHT            = 7
-        ,BlendType_SCREEN           = 8
-        ,BlendType_OVERLAY          = 9
-        ,BlendType_BLEND_HUE        = 10
-        ,BlendType_BLEND_SAT        = 11
-        ,BlendType_BLEND_VAL        = 12
-        ,BlendType_BLEND_COLOR      = 13
+        BlendType_BLEND = 0,
+        BlendType_MUL = 1,
+        BlendType_ADD = 2,
+        BlendType_SUB = 3,
+        BlendType_DIV = 4,
+        BlendType_DARK = 5,
+        BlendType_DIFF = 6,
+        BlendType_LIGHT = 7,
+        BlendType_SCREEN = 8,
+        BlendType_OVERLAY = 9,
+        BlendType_BLEND_HUE = 10,
+        BlendType_BLEND_SAT = 11,
+        BlendType_BLEND_VAL = 12,
+        BlendType_BLEND_COLOR = 13
     };
 
     enum MapType {
-         MapType_COL         = 1
-        ,MapType_NORM        = 2
-        ,MapType_COLSPEC     = 4
-        ,MapType_COLMIR      = 8
-        ,MapType_REF         = 16
-        ,MapType_SPEC        = 32
-        ,MapType_EMIT        = 64
-        ,MapType_ALPHA       = 128
-        ,MapType_HAR         = 256
-        ,MapType_RAYMIRR     = 512
-        ,MapType_TRANSLU     = 1024
-        ,MapType_AMB         = 2048
-        ,MapType_DISPLACE    = 4096
-        ,MapType_WARP        = 8192
+        MapType_COL = 1,
+        MapType_NORM = 2,
+        MapType_COLSPEC = 4,
+        MapType_COLMIR = 8,
+        MapType_REF = 16,
+        MapType_SPEC = 32,
+        MapType_EMIT = 64,
+        MapType_ALPHA = 128,
+        MapType_HAR = 256,
+        MapType_RAYMIRR = 512,
+        MapType_TRANSLU = 1024,
+        MapType_AMB = 2048,
+        MapType_DISPLACE = 4096,
+        MapType_WARP = 8192
     };
 
     // short texco, maptoneg;
@@ -945,7 +920,7 @@ struct MTex : ElemBase {
     std::shared_ptr<Tex> tex;
     char uvname[32];
 
-    Projection projx,projy,projz;
+    Projection projx, projy, projz;
     char mapping;
     float ofs[3], size[3], rot;
 
@@ -953,7 +928,7 @@ struct MTex : ElemBase {
     short colormodel, pmapto, pmaptoneg;
     //short normapspace, which_output;
     //char brush_map_mode;
-    float r,g,b,k WARN;
+    float r, g, b, k WARN;
     //float def_var, rt;
 
     //float colfac, varfac;
@@ -972,12 +947,12 @@ struct MTex : ElemBase {
     //float shadowfac;
     //float zenupfac, zendownfac, blendfac;
 
-    MTex()
-    : ElemBase() {
+    MTex() :
+            ElemBase() {
         // empty
     }
 };
 
-}
-}
+} // namespace Blender
+} // namespace Assimp
 #endif
diff --git a/code/Blender/BlenderSceneGen.h b/code/AssetLib/Blender/BlenderSceneGen.h
similarity index 100%
rename from code/Blender/BlenderSceneGen.h
rename to code/AssetLib/Blender/BlenderSceneGen.h
diff --git a/code/Blender/BlenderTessellator.cpp b/code/AssetLib/Blender/BlenderTessellator.cpp
similarity index 100%
rename from code/Blender/BlenderTessellator.cpp
rename to code/AssetLib/Blender/BlenderTessellator.cpp
diff --git a/code/Blender/BlenderTessellator.h b/code/AssetLib/Blender/BlenderTessellator.h
similarity index 100%
rename from code/Blender/BlenderTessellator.h
rename to code/AssetLib/Blender/BlenderTessellator.h
diff --git a/code/C4D/C4DImporter.cpp b/code/AssetLib/C4D/C4DImporter.cpp
similarity index 100%
rename from code/C4D/C4DImporter.cpp
rename to code/AssetLib/C4D/C4DImporter.cpp
diff --git a/code/C4D/C4DImporter.h b/code/AssetLib/C4D/C4DImporter.h
similarity index 100%
rename from code/C4D/C4DImporter.h
rename to code/AssetLib/C4D/C4DImporter.h
diff --git a/code/COB/COBLoader.cpp b/code/AssetLib/COB/COBLoader.cpp
similarity index 53%
rename from code/COB/COBLoader.cpp
rename to code/AssetLib/COB/COBLoader.cpp
index b9ea8aff5..d66fb4f4c 100644
--- a/code/COB/COBLoader.cpp
+++ b/code/AssetLib/COB/COBLoader.cpp
@@ -43,21 +43,20 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of the TrueSpace COB/SCN importer class.
  */
 
-
 #ifndef ASSIMP_BUILD_NO_COB_IMPORTER
-#include "COB/COBLoader.h"
-#include "COB/COBScene.h"
+#include "AssetLib/COB/COBLoader.h"
+#include "AssetLib/COB/COBScene.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
-#include <assimp/StreamReader.h>
-#include <assimp/ParsingUtils.h>
-#include <assimp/fast_atof.h>
 #include <assimp/LineSplitter.h>
+#include <assimp/ParsingUtils.h>
+#include <assimp/StreamReader.h>
 #include <assimp/TinyFormatter.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/scene.h>
+#include <assimp/fast_atof.h>
 #include <assimp/importerdesc.h>
+#include <assimp/scene.h>
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/IOSystem.hpp>
 
 #include <memory>
 
@@ -65,16 +64,15 @@ using namespace Assimp;
 using namespace Assimp::COB;
 using namespace Assimp::Formatter;
 
-
 static const float units[] = {
     1000.f,
     100.f,
     1.f,
     0.001f,
-    1.f/0.0254f,
-    1.f/0.3048f,
-    1.f/0.9144f,
-    1.f/1609.344f
+    1.f / 0.0254f,
+    1.f / 0.3048f,
+    1.f / 0.9144f,
+    1.f / 1609.344f
 };
 
 static const aiImporterDesc desc = {
@@ -90,238 +88,227 @@ static const aiImporterDesc desc = {
     "cob scn"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-COBImporter::COBImporter()
-{}
+COBImporter::COBImporter() {}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-COBImporter::~COBImporter()
-{}
+COBImporter::~COBImporter() {}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool COBImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
-{
-    const std::string& extension = GetExtension(pFile);
+bool COBImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
+    const std::string &extension = GetExtension(pFile);
     if (extension == "cob" || extension == "scn" || extension == "COB" || extension == "SCN") {
         return true;
     }
 
-    else if ((!extension.length() || checkSig) && pIOHandler)   {
-        const char* tokens[] = {"Caligary"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
+    else if ((!extension.length() || checkSig) && pIOHandler) {
+        const char *tokens[] = { "Caligary" };
+        return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 1);
     }
     return false;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Loader meta information
-const aiImporterDesc* COBImporter::GetInfo () const
-{
+const aiImporterDesc *COBImporter::GetInfo() const {
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void COBImporter::SetupProperties(const Importer* /*pImp*/)
-{
+void COBImporter::SetupProperties(const Importer * /*pImp*/) {
     // nothing to be done for the moment
 }
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string& msg)
-{
-    throw DeadlyImportError("COB: "+msg);
+/*static*/ AI_WONT_RETURN void COBImporter::ThrowException(const std::string &msg) {
+    throw DeadlyImportError("COB: " + msg);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
-void COBImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
+void COBImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     COB::Scene scene;
-    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
+    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE(pIOHandler->Open(pFile, "rb")));
 
     // check header
     char head[32];
-    stream->CopyAndAdvance(head,32);
-    if (strncmp(head,"Caligari ",9) != 0) {
+    stream->CopyAndAdvance(head, 32);
+    if (strncmp(head, "Caligari ", 9) != 0) {
         ThrowException("Could not found magic id: `Caligari`");
     }
 
-    ASSIMP_LOG_INFO_F("File format tag: ",std::string(head+9,6));
-    if (head[16]!='L') {
+    ASSIMP_LOG_INFO_F("File format tag: ", std::string(head + 9, 6));
+    if (head[16] != 'L') {
         ThrowException("File is big-endian, which is not supported");
     }
 
     // load data into intermediate structures
-    if (head[15]=='A') {
+    if (head[15] == 'A') {
         ReadAsciiFile(scene, stream.get());
-    }
-    else {
+    } else {
         ReadBinaryFile(scene, stream.get());
     }
-    if(scene.nodes.empty()) {
+    if (scene.nodes.empty()) {
         ThrowException("No nodes loaded");
     }
 
     // sort faces by material indices
-    for(std::shared_ptr< Node >& n : scene.nodes) {
+    for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
-            Mesh& mesh = (Mesh&)(*n.get());
-            for(Face& f : mesh.faces) {
+            Mesh &mesh = (Mesh &)(*n.get());
+            for (Face &f : mesh.faces) {
                 mesh.temp_map[f.material].push_back(&f);
             }
         }
     }
 
     // count meshes
-    for(std::shared_ptr< Node >& n : scene.nodes) {
+    for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
-            Mesh& mesh = (Mesh&)(*n.get());
+            Mesh &mesh = (Mesh &)(*n.get());
             if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
                 pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size());
             }
         }
     }
-    pScene->mMeshes = new aiMesh*[pScene->mNumMeshes]();
-    pScene->mMaterials = new aiMaterial*[pScene->mNumMeshes]();
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes]();
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMeshes]();
     pScene->mNumMeshes = 0;
 
     // count lights and cameras
-    for(std::shared_ptr< Node >& n : scene.nodes) {
+    for (std::shared_ptr<Node> &n : scene.nodes) {
         if (n->type == Node::TYPE_LIGHT) {
             ++pScene->mNumLights;
-        }
-        else if (n->type == Node::TYPE_CAMERA) {
+        } else if (n->type == Node::TYPE_CAMERA) {
             ++pScene->mNumCameras;
         }
     }
 
     if (pScene->mNumLights) {
-        pScene->mLights  = new aiLight*[pScene->mNumLights]();
+        pScene->mLights = new aiLight *[pScene->mNumLights]();
     }
     if (pScene->mNumCameras) {
-        pScene->mCameras = new aiCamera*[pScene->mNumCameras]();
+        pScene->mCameras = new aiCamera *[pScene->mNumCameras]();
     }
     pScene->mNumLights = pScene->mNumCameras = 0;
 
     // resolve parents by their IDs and build the output graph
     std::unique_ptr<Node> root(new Group());
-    for(size_t n = 0; n < scene.nodes.size(); ++n) {
-        const Node& nn = *scene.nodes[n].get();
-        if(nn.parent_id==0) {
+    for (size_t n = 0; n < scene.nodes.size(); ++n) {
+        const Node &nn = *scene.nodes[n].get();
+        if (nn.parent_id == 0) {
             root->temp_children.push_back(&nn);
         }
 
-        for(size_t m = n; m < scene.nodes.size(); ++m) {
-            const Node& mm = *scene.nodes[m].get();
+        for (size_t m = n; m < scene.nodes.size(); ++m) {
+            const Node &mm = *scene.nodes[m].get();
             if (mm.parent_id == nn.id) {
                 nn.temp_children.push_back(&mm);
             }
         }
     }
 
-    pScene->mRootNode = BuildNodes(*root.get(),scene,pScene);
-	//flip normals after import
+    pScene->mRootNode = BuildNodes(*root.get(), scene, pScene);
+    //flip normals after import
     FlipWindingOrderProcess flip;
-    flip.Execute( pScene );
+    flip.Execute(pScene);
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertTexture(std::shared_ptr< Texture > tex, aiMaterial* out, aiTextureType type)
-{
-    const aiString path( tex->path );
-    out->AddProperty(&path,AI_MATKEY_TEXTURE(type,0));
-    out->AddProperty(&tex->transform,1,AI_MATKEY_UVTRANSFORM(type,0));
+void ConvertTexture(std::shared_ptr<Texture> tex, aiMaterial *out, aiTextureType type) {
+    const aiString path(tex->path);
+    out->AddProperty(&path, AI_MATKEY_TEXTURE(type, 0));
+    out->AddProperty(&tex->transform, 1, AI_MATKEY_UVTRANSFORM(type, 0));
 }
 
 // ------------------------------------------------------------------------------------------------
-aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill)
-{
-    aiNode* nd = new aiNode();
+aiNode *COBImporter::BuildNodes(const Node &root, const Scene &scin, aiScene *fill) {
+    aiNode *nd = new aiNode();
     nd->mName.Set(root.name);
     nd->mTransformation = root.transform;
 
     // Note to everybody believing Voodoo is appropriate here:
     // I know polymorphism, run as fast as you can ;-)
     if (Node::TYPE_MESH == root.type) {
-        const Mesh& ndmesh = (const Mesh&)(root);
+        const Mesh &ndmesh = (const Mesh &)(root);
         if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) {
 
-            typedef std::pair<const unsigned int,Mesh::FaceRefList> Entry;
-            for(const Entry& reflist : ndmesh.temp_map) {
-                {   // create mesh
+            typedef std::pair<const unsigned int, Mesh::FaceRefList> Entry;
+            for (const Entry &reflist : ndmesh.temp_map) {
+                { // create mesh
                     size_t n = 0;
-                    for(Face* f : reflist.second) {
+                    for (Face *f : reflist.second) {
                         n += f->indices.size();
                     }
                     if (!n) {
                         continue;
                     }
-                    aiMesh* outmesh = fill->mMeshes[fill->mNumMeshes++] = new aiMesh();
+                    aiMesh *outmesh = fill->mMeshes[fill->mNumMeshes++] = new aiMesh();
                     ++nd->mNumMeshes;
 
                     outmesh->mVertices = new aiVector3D[n];
                     outmesh->mTextureCoords[0] = new aiVector3D[n];
 
                     outmesh->mFaces = new aiFace[reflist.second.size()]();
-                    for(Face* f : reflist.second) {
+                    for (Face *f : reflist.second) {
                         if (f->indices.empty()) {
                             continue;
                         }
 
-                        aiFace& fout = outmesh->mFaces[outmesh->mNumFaces++];
+                        aiFace &fout = outmesh->mFaces[outmesh->mNumFaces++];
                         fout.mIndices = new unsigned int[f->indices.size()];
 
-                        for(VertexIndex& v : f->indices) {
+                        for (VertexIndex &v : f->indices) {
                             if (v.pos_idx >= ndmesh.vertex_positions.size()) {
                                 ThrowException("Position index out of range");
                             }
                             if (v.uv_idx >= ndmesh.texture_coords.size()) {
                                 ThrowException("UV index out of range");
                             }
-                            outmesh->mVertices[outmesh->mNumVertices] = ndmesh.vertex_positions[ v.pos_idx ];
+                            outmesh->mVertices[outmesh->mNumVertices] = ndmesh.vertex_positions[v.pos_idx];
                             outmesh->mTextureCoords[0][outmesh->mNumVertices] = aiVector3D(
-                                ndmesh.texture_coords[ v.uv_idx ].x,
-                                ndmesh.texture_coords[ v.uv_idx ].y,
-                                0.f
-                            );
+                                    ndmesh.texture_coords[v.uv_idx].x,
+                                    ndmesh.texture_coords[v.uv_idx].y,
+                                    0.f);
 
                             fout.mIndices[fout.mNumIndices++] = outmesh->mNumVertices++;
                         }
                     }
                     outmesh->mMaterialIndex = fill->mNumMaterials;
-                }{  // create material
-                    const Material* min = NULL;
-                    for(const Material& m : scin.materials) {
+                }
+                { // create material
+                    const Material *min = nullptr;
+                    for (const Material &m : scin.materials) {
                         if (m.parent_id == ndmesh.id && m.matnum == reflist.first) {
                             min = &m;
                             break;
                         }
                     }
                     std::unique_ptr<const Material> defmat;
-                    if(!min) {
-                        ASSIMP_LOG_DEBUG(format()<<"Could not resolve material index "
-                            <<reflist.first<<" - creating default material for this slot");
+                    if (!min) {
+                        ASSIMP_LOG_DEBUG(format() << "Could not resolve material index "
+                                                  << reflist.first << " - creating default material for this slot");
 
-                        defmat.reset(min=new Material());
+                        defmat.reset(min = new Material());
                     }
 
-                    aiMaterial* mat = new aiMaterial();
+                    aiMaterial *mat = new aiMaterial();
                     fill->mMaterials[fill->mNumMaterials++] = mat;
 
-                    const aiString s(format("#mat_")<<fill->mNumMeshes<<"_"<<min->matnum);
-                    mat->AddProperty(&s,AI_MATKEY_NAME);
+                    const aiString s(format("#mat_") << fill->mNumMeshes << "_" << min->matnum);
+                    mat->AddProperty(&s, AI_MATKEY_NAME);
 
-                    if(int tmp = ndmesh.draw_flags & Mesh::WIRED ? 1 : 0) {
-                        mat->AddProperty(&tmp,1,AI_MATKEY_ENABLE_WIREFRAME);
+                    if (int tmp = ndmesh.draw_flags & Mesh::WIRED ? 1 : 0) {
+                        mat->AddProperty(&tmp, 1, AI_MATKEY_ENABLE_WIREFRAME);
                     }
 
-                    {   int shader;
-                        switch(min->shader)
-                        {
+                    {
+                        int shader;
+                        switch (min->shader) {
                         case Material::FLAT:
                             shader = aiShadingMode_Gouraud;
                             break;
@@ -337,38 +324,37 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
                         default:
                             ai_assert(false); // shouldn't be here
                         }
-                        mat->AddProperty(&shader,1,AI_MATKEY_SHADING_MODEL);
-                        if(shader != aiShadingMode_Gouraud) {
-                            mat->AddProperty(&min->exp,1,AI_MATKEY_SHININESS);
+                        mat->AddProperty(&shader, 1, AI_MATKEY_SHADING_MODEL);
+                        if (shader != aiShadingMode_Gouraud) {
+                            mat->AddProperty(&min->exp, 1, AI_MATKEY_SHININESS);
                         }
                     }
 
-                    mat->AddProperty(&min->ior,1,AI_MATKEY_REFRACTI);
-                    mat->AddProperty(&min->rgb,1,AI_MATKEY_COLOR_DIFFUSE);
+                    mat->AddProperty(&min->ior, 1, AI_MATKEY_REFRACTI);
+                    mat->AddProperty(&min->rgb, 1, AI_MATKEY_COLOR_DIFFUSE);
 
-                    aiColor3D c = aiColor3D(min->rgb)*min->ks;
-                    mat->AddProperty(&c,1,AI_MATKEY_COLOR_SPECULAR);
+                    aiColor3D c = aiColor3D(min->rgb) * min->ks;
+                    mat->AddProperty(&c, 1, AI_MATKEY_COLOR_SPECULAR);
 
-                    c = aiColor3D(min->rgb)*min->ka;
-                    mat->AddProperty(&c,1,AI_MATKEY_COLOR_AMBIENT);
+                    c = aiColor3D(min->rgb) * min->ka;
+                    mat->AddProperty(&c, 1, AI_MATKEY_COLOR_AMBIENT);
 
                     // convert textures if some exist.
-                    if(min->tex_color) {
-                        ConvertTexture(min->tex_color,mat,aiTextureType_DIFFUSE);
+                    if (min->tex_color) {
+                        ConvertTexture(min->tex_color, mat, aiTextureType_DIFFUSE);
                     }
-                    if(min->tex_env) {
-                        ConvertTexture(min->tex_env  ,mat,aiTextureType_UNKNOWN);
+                    if (min->tex_env) {
+                        ConvertTexture(min->tex_env, mat, aiTextureType_UNKNOWN);
                     }
-                    if(min->tex_bump) {
-                        ConvertTexture(min->tex_bump ,mat,aiTextureType_HEIGHT);
+                    if (min->tex_bump) {
+                        ConvertTexture(min->tex_bump, mat, aiTextureType_HEIGHT);
                     }
                 }
             }
         }
-    }
-    else if (Node::TYPE_LIGHT == root.type) {
-        const Light& ndlight = (const Light&)(root);
-        aiLight* outlight = fill->mLights[fill->mNumLights++] = new aiLight();
+    } else if (Node::TYPE_LIGHT == root.type) {
+        const Light &ndlight = (const Light &)(root);
+        aiLight *outlight = fill->mLights[fill->mNumLights++] = new aiLight();
 
         outlight->mName.Set(ndlight.name);
         outlight->mColorDiffuse = outlight->mColorAmbient = outlight->mColorSpecular = ndlight.color;
@@ -377,27 +363,26 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
         outlight->mAngleInnerCone = AI_DEG_TO_RAD(ndlight.inner_angle);
 
         // XXX
-        outlight->mType = ndlight.ltype==Light::SPOT ? aiLightSource_SPOT : aiLightSource_DIRECTIONAL;
-    }
-    else if (Node::TYPE_CAMERA == root.type) {
-        const Camera& ndcam = (const Camera&)(root);
-        aiCamera* outcam = fill->mCameras[fill->mNumCameras++] = new aiCamera();
+        outlight->mType = ndlight.ltype == Light::SPOT ? aiLightSource_SPOT : aiLightSource_DIRECTIONAL;
+    } else if (Node::TYPE_CAMERA == root.type) {
+        const Camera &ndcam = (const Camera &)(root);
+        aiCamera *outcam = fill->mCameras[fill->mNumCameras++] = new aiCamera();
 
         outcam->mName.Set(ndcam.name);
     }
 
     // add meshes
-    if (nd->mNumMeshes) { // mMeshes must be NULL if count is 0
+    if (nd->mNumMeshes) { // mMeshes must be nullptr if count is 0
         nd->mMeshes = new unsigned int[nd->mNumMeshes];
-        for(unsigned int i = 0; i < nd->mNumMeshes;++i) {
-            nd->mMeshes[i] = fill->mNumMeshes-i-1;
+        for (unsigned int i = 0; i < nd->mNumMeshes; ++i) {
+            nd->mMeshes[i] = fill->mNumMeshes - i - 1;
         }
     }
 
     // add children recursively
-    nd->mChildren = new aiNode*[root.temp_children.size()]();
-    for(const Node* n : root.temp_children) {
-        (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n,scin,fill))->mParent = nd;
+    nd->mChildren = new aiNode *[root.temp_children.size()]();
+    for (const Node *n : root.temp_children) {
+        (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n, scin, fill))->mParent = nd;
     }
 
     return nd;
@@ -405,47 +390,46 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
 
 // ------------------------------------------------------------------------------------------------
 // Read an ASCII file into the given scene data structure
-void COBImporter::ReadAsciiFile(Scene& out, StreamReaderLE* stream)
-{
+void COBImporter::ReadAsciiFile(Scene &out, StreamReaderLE *stream) {
     ChunkInfo ci;
-    for(LineSplitter splitter(*stream);splitter;++splitter) {
+    for (LineSplitter splitter(*stream); splitter; ++splitter) {
 
         // add all chunks to be recognized here. /else ../ omitted intentionally.
         if (splitter.match_start("PolH ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadPolH_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadPolH_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("BitM ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadBitM_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadBitM_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Mat1 ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadMat1_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadMat1_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Grou ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadGrou_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadGrou_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Lght ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadLght_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadLght_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Came ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadCame_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadCame_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Bone ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadBone_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadBone_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Chan ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadChan_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadChan_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("Unit ")) {
-            ReadChunkInfo_Ascii(ci,splitter);
-            ReadUnit_Ascii(out,splitter,ci);
+            ReadChunkInfo_Ascii(ci, splitter);
+            ReadUnit_Ascii(out, splitter, ci);
         }
         if (splitter.match_start("END ")) {
             // we don't need this, but I guess there is a reason this
@@ -456,25 +440,22 @@ void COBImporter::ReadAsciiFile(Scene& out, StreamReaderLE* stream)
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadChunkInfo_Ascii(ChunkInfo& out, const LineSplitter& splitter)
-{
-    const char* all_tokens[8];
+void COBImporter::ReadChunkInfo_Ascii(ChunkInfo &out, const LineSplitter &splitter) {
+    const char *all_tokens[8];
     splitter.get_tokens(all_tokens);
 
-    out.version = (all_tokens[1][1]-'0')*100+(all_tokens[1][3]-'0')*10+(all_tokens[1][4]-'0');
-    out.id  = strtoul10(all_tokens[3]);
+    out.version = (all_tokens[1][1] - '0') * 100 + (all_tokens[1][3] - '0') * 10 + (all_tokens[1][4] - '0');
+    out.id = strtoul10(all_tokens[3]);
     out.parent_id = strtoul10(all_tokens[5]);
     out.size = strtol10(all_tokens[7]);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo& nfo, const char* name)
-{
-    const std::string error = format("Encountered unsupported chunk: ") <<  name <<
-        " [version: "<<nfo.version<<", size: "<<nfo.size<<"]";
+void COBImporter::UnsupportedChunk_Ascii(LineSplitter &splitter, const ChunkInfo &nfo, const char *name) {
+    const std::string error = format("Encountered unsupported chunk: ") << name << " [version: " << nfo.version << ", size: " << nfo.size << "]";
 
     // we can recover if the chunk size was specified.
-    if(nfo.size != static_cast<unsigned int>(-1)) {
+    if (nfo.size != static_cast<unsigned int>(-1)) {
         ASSIMP_LOG_ERROR(error);
 
         // (HACK) - our current position in the stream is the beginning of the
@@ -483,25 +464,23 @@ void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo
         // missing the next line.
         splitter.get_stream().IncPtr(nfo.size);
         splitter.swallow_next_increment();
-    }
-    else ThrowException(error);
+    } else
+        ThrowException(error);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, const ChunkInfo& /*nfo*/)
-{
-    for(;splitter;++splitter) {
+void COBImporter::ReadBasicNodeInfo_Ascii(Node &msh, LineSplitter &splitter, const ChunkInfo & /*nfo*/) {
+    for (; splitter; ++splitter) {
         if (splitter.match_start("Name")) {
             msh.name = std::string(splitter[1]);
 
             // make nice names by merging the dupe count
-            std::replace(msh.name.begin(),msh.name.end(),
-                ',','_');
-        }
-        else if (splitter.match_start("Transform")) {
-            for(unsigned int y = 0; y < 4 && ++splitter; ++y) {
-                const char* s = splitter->c_str();
-                for(unsigned int x = 0; x < 4; ++x) {
+            std::replace(msh.name.begin(), msh.name.end(),
+                    ',', '_');
+        } else if (splitter.match_start("Transform")) {
+            for (unsigned int y = 0; y < 4 && ++splitter; ++y) {
+                const char *s = splitter->c_str();
+                for (unsigned int x = 0; x < 4; ++x) {
                     SkipSpaces(&s);
                     msh.transform[y][x] = fast_atof(&s);
                 }
@@ -514,12 +493,11 @@ void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, con
 
 // ------------------------------------------------------------------------------------------------
 template <typename T>
-void COBImporter::ReadFloat3Tuple_Ascii(T& fill, const char** in)
-{
-    const char* rgb = *in;
-    for(unsigned int i = 0; i < 3; ++i) {
+void COBImporter::ReadFloat3Tuple_Ascii(T &fill, const char **in) {
+    const char *rgb = *in;
+    for (unsigned int i = 0; i < 3; ++i) {
         SkipSpaces(&rgb);
-        if (*rgb == ',')++rgb;
+        if (*rgb == ',') ++rgb;
         SkipSpaces(&rgb);
 
         fill[i] = fast_atof(&rgb);
@@ -528,164 +506,154 @@ void COBImporter::ReadFloat3Tuple_Ascii(T& fill, const char** in)
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Mat1");
+void COBImporter::ReadMat1_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Mat1");
     }
 
     ++splitter;
     if (!splitter.match_start("mat# ")) {
-        ASSIMP_LOG_WARN_F( "Expected `mat#` line in `Mat1` chunk ", nfo.id );
+        ASSIMP_LOG_WARN_F("Expected `mat#` line in `Mat1` chunk ", nfo.id);
         return;
     }
 
     out.materials.push_back(Material());
-    Material& mat = out.materials.back();
+    Material &mat = out.materials.back();
     mat = nfo;
 
     mat.matnum = strtoul10(splitter[1]);
     ++splitter;
 
     if (!splitter.match_start("shader: ")) {
-        ASSIMP_LOG_WARN_F( "Expected `mat#` line in `Mat1` chunk ", nfo.id);
+        ASSIMP_LOG_WARN_F("Expected `mat#` line in `Mat1` chunk ", nfo.id);
         return;
     }
     std::string shader = std::string(splitter[1]);
-    shader = shader.substr(0,shader.find_first_of(" \t"));
+    shader = shader.substr(0, shader.find_first_of(" \t"));
 
     if (shader == "metal") {
         mat.shader = Material::METAL;
-    }
-    else if (shader == "phong") {
+    } else if (shader == "phong") {
         mat.shader = Material::PHONG;
-    }
-    else if (shader != "flat") {
-        ASSIMP_LOG_WARN_F( "Unknown value for `shader` in `Mat1` chunk ", nfo.id );
+    } else if (shader != "flat") {
+        ASSIMP_LOG_WARN_F("Unknown value for `shader` in `Mat1` chunk ", nfo.id);
     }
 
     ++splitter;
     if (!splitter.match_start("rgb ")) {
-        ASSIMP_LOG_WARN_F( "Expected `rgb` line in `Mat1` chunk ", nfo.id);
+        ASSIMP_LOG_WARN_F("Expected `rgb` line in `Mat1` chunk ", nfo.id);
     }
 
-    const char* rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(mat.rgb,&rgb);
+    const char *rgb = splitter[1];
+    ReadFloat3Tuple_Ascii(mat.rgb, &rgb);
 
     ++splitter;
     if (!splitter.match_start("alpha ")) {
-        ASSIMP_LOG_WARN_F( "Expected `alpha` line in `Mat1` chunk ", nfo.id);
+        ASSIMP_LOG_WARN_F("Expected `alpha` line in `Mat1` chunk ", nfo.id);
     }
 
-    const char* tokens[10];
+    const char *tokens[10];
     splitter.get_tokens(tokens);
 
-    mat.alpha   = fast_atof( tokens[1] );
-    mat.ka      = fast_atof( tokens[3] );
-    mat.ks      = fast_atof( tokens[5] );
-    mat.exp     = fast_atof( tokens[7] );
-    mat.ior     = fast_atof( tokens[9] );
+    mat.alpha = fast_atof(tokens[1]);
+    mat.ka = fast_atof(tokens[3]);
+    mat.ks = fast_atof(tokens[5]);
+    mat.exp = fast_atof(tokens[7]);
+    mat.ior = fast_atof(tokens[9]);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadUnit_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Unit");
+void COBImporter::ReadUnit_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Unit");
     }
     ++splitter;
     if (!splitter.match_start("Units ")) {
-        ASSIMP_LOG_WARN_F( "Expected `Units` line in `Unit` chunk ", nfo.id);
+        ASSIMP_LOG_WARN_F("Expected `Units` line in `Unit` chunk ", nfo.id);
         return;
     }
 
     // parent chunks preceede their childs, so we should have the
     // corresponding chunk already.
-    for(std::shared_ptr< Node >& nd : out.nodes) {
+    for (std::shared_ptr<Node> &nd : out.nodes) {
         if (nd->id == nfo.parent_id) {
-            const unsigned int t=strtoul10(splitter[1]);
+            const unsigned int t = strtoul10(splitter[1]);
 
-            nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(
-                ASSIMP_LOG_WARN_F(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id)
-                ,1.f):units[t];
+            nd->unit_scale = t >= sizeof(units) / sizeof(units[0]) ? (
+                                                                             ASSIMP_LOG_WARN_F(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id), 1.f) :
+                                                                     units[t];
             return;
         }
     }
-    ASSIMP_LOG_WARN_F( "`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
+    ASSIMP_LOG_WARN_F("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadChan_Ascii(Scene& /*out*/, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Chan");
+void COBImporter::ReadChan_Ascii(Scene & /*out*/, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Chan");
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadLght_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Lght");
+void COBImporter::ReadLght_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Lght");
     }
 
     out.nodes.push_back(std::shared_ptr<Light>(new Light()));
-    Light& msh = (Light&)(*out.nodes.back().get());
+    Light &msh = (Light &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     if (splitter.match_start("Infinite ")) {
         msh.ltype = Light::INFINITE;
-    }
-    else if (splitter.match_start("Local ")) {
+    } else if (splitter.match_start("Local ")) {
         msh.ltype = Light::LOCAL;
-    }
-    else if (splitter.match_start("Spot ")) {
+    } else if (splitter.match_start("Spot ")) {
         msh.ltype = Light::SPOT;
-    }
-    else {
-        ASSIMP_LOG_WARN_F( "Unknown kind of light source in `Lght` chunk ", nfo.id, " : ", *splitter );
+    } else {
+        ASSIMP_LOG_WARN_F("Unknown kind of light source in `Lght` chunk ", nfo.id, " : ", *splitter);
         msh.ltype = Light::SPOT;
     }
 
     ++splitter;
     if (!splitter.match_start("color ")) {
-        ASSIMP_LOG_WARN_F( "Expected `color` line in `Lght` chunk ", nfo.id );
+        ASSIMP_LOG_WARN_F("Expected `color` line in `Lght` chunk ", nfo.id);
     }
 
-    const char* rgb = splitter[1];
-    ReadFloat3Tuple_Ascii(msh.color ,&rgb);
+    const char *rgb = splitter[1];
+    ReadFloat3Tuple_Ascii(msh.color, &rgb);
 
     SkipSpaces(&rgb);
-    if (strncmp(rgb,"cone angle",10) != 0) {
-        ASSIMP_LOG_WARN_F( "Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id );
+    if (strncmp(rgb, "cone angle", 10) != 0) {
+        ASSIMP_LOG_WARN_F("Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id);
     }
-    SkipSpaces(rgb+10,&rgb);
+    SkipSpaces(rgb + 10, &rgb);
     msh.angle = fast_atof(&rgb);
 
     SkipSpaces(&rgb);
-    if (strncmp(rgb,"inner angle",11) != 0) {
-        ASSIMP_LOG_WARN_F( "Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
+    if (strncmp(rgb, "inner angle", 11) != 0) {
+        ASSIMP_LOG_WARN_F("Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
     }
-    SkipSpaces(rgb+11,&rgb);
+    SkipSpaces(rgb + 11, &rgb);
     msh.inner_angle = fast_atof(&rgb);
 
     // skip the rest for we can't handle this kind of physically-based lighting information.
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadCame_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Came");
+void COBImporter::ReadCame_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Came");
     }
 
     out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
-    Camera& msh = (Camera&)(*out.nodes.back().get());
+    Camera &msh = (Camera &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     // skip the next line, we don't know this differenciation between a
     // standard camera and a panoramic camera.
@@ -693,60 +661,57 @@ void COBImporter::ReadCame_Ascii(Scene& out, LineSplitter& splitter, const Chunk
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBone_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 5) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Bone");
+void COBImporter::ReadBone_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 5) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Bone");
     }
 
     out.nodes.push_back(std::shared_ptr<Bone>(new Bone()));
-    Bone& msh = (Bone&)(*out.nodes.back().get());
+    Bone &msh = (Bone &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     // TODO
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadGrou_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"Grou");
+void COBImporter::ReadGrou_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "Grou");
     }
 
     out.nodes.push_back(std::shared_ptr<Group>(new Group()));
-    Group& msh = (Group&)(*out.nodes.back().get());
+    Group &msh = (Group &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"PolH");
+void COBImporter::ReadPolH_Ascii(Scene &out, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "PolH");
     }
 
     out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
-    Mesh& msh = (Mesh&)(*out.nodes.back().get());
+    Mesh &msh = (Mesh &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Ascii(msh,++splitter,nfo);
+    ReadBasicNodeInfo_Ascii(msh, ++splitter, nfo);
 
     // the chunk has a fixed order of components, but some are not interesting of us so
     // we're just looking for keywords in arbitrary order. The end of the chunk is
     // either the last `Face` or the `DrawFlags` attribute, depending on the format ver.
-    for(;splitter;++splitter) {
+    for (; splitter; ++splitter) {
         if (splitter.match_start("World Vertices")) {
             const unsigned int cnt = strtoul10(splitter[2]);
             msh.vertex_positions.resize(cnt);
 
-            for(unsigned int cur = 0;cur < cnt && ++splitter;++cur) {
-                const char* s = splitter->c_str();
+            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
+                const char *s = splitter->c_str();
 
-                aiVector3D& v = msh.vertex_positions[cur];
+                aiVector3D &v = msh.vertex_positions[cur];
 
                 SkipSpaces(&s);
                 v.x = fast_atof(&s);
@@ -755,29 +720,27 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
                 SkipSpaces(&s);
                 v.z = fast_atof(&s);
             }
-        }
-        else if (splitter.match_start("Texture Vertices")) {
+        } else if (splitter.match_start("Texture Vertices")) {
             const unsigned int cnt = strtoul10(splitter[2]);
             msh.texture_coords.resize(cnt);
 
-            for(unsigned int cur = 0;cur < cnt && ++splitter;++cur) {
-                const char* s = splitter->c_str();
+            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
+                const char *s = splitter->c_str();
 
-                aiVector2D& v = msh.texture_coords[cur];
+                aiVector2D &v = msh.texture_coords[cur];
 
                 SkipSpaces(&s);
                 v.x = fast_atof(&s);
                 SkipSpaces(&s);
                 v.y = fast_atof(&s);
             }
-        }
-        else if (splitter.match_start("Faces")) {
+        } else if (splitter.match_start("Faces")) {
             const unsigned int cnt = strtoul10(splitter[1]);
             msh.faces.reserve(cnt);
 
-            for(unsigned int cur = 0; cur < cnt && ++splitter ;++cur) {
+            for (unsigned int cur = 0; cur < cnt && ++splitter; ++cur) {
                 if (splitter.match_start("Hole")) {
-                    ASSIMP_LOG_WARN( "Skipping unsupported `Hole` line" );
+                    ASSIMP_LOG_WARN("Skipping unsupported `Hole` line");
                     continue;
                 }
 
@@ -786,25 +749,25 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
                 }
 
                 msh.faces.push_back(Face());
-                Face& face = msh.faces.back();
+                Face &face = msh.faces.back();
 
                 face.indices.resize(strtoul10(splitter[2]));
                 face.flags = strtoul10(splitter[4]);
                 face.material = strtoul10(splitter[6]);
 
-                const char* s = (++splitter)->c_str();
-                for(size_t i = 0; i < face.indices.size(); ++i) {
-                    if(!SkipSpaces(&s)) {
+                const char *s = (++splitter)->c_str();
+                for (size_t i = 0; i < face.indices.size(); ++i) {
+                    if (!SkipSpaces(&s)) {
                         ThrowException("Expected EOL token in Face entry");
                     }
                     if ('<' != *s++) {
                         ThrowException("Expected < token in Face entry");
                     }
-                    face.indices[i].pos_idx = strtoul10(s,&s);
+                    face.indices[i].pos_idx = strtoul10(s, &s);
                     if (',' != *s++) {
                         ThrowException("Expected , token in Face entry");
                     }
-                    face.indices[i].uv_idx = strtoul10(s,&s);
+                    face.indices[i].uv_idx = strtoul10(s, &s);
                     if ('>' != *s++) {
                         ThrowException("Expected < token in Face entry");
                     }
@@ -813,8 +776,7 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
             if (nfo.version <= 4) {
                 break;
             }
-        }
-        else if (splitter.match_start("DrawFlags")) {
+        } else if (splitter.match_start("DrawFlags")) {
             msh.draw_flags = strtoul10(splitter[1]);
             break;
         }
@@ -822,12 +784,11 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBitM_Ascii(Scene& /*out*/, LineSplitter& splitter, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Ascii(splitter,nfo,"BitM");
+void COBImporter::ReadBitM_Ascii(Scene & /*out*/, LineSplitter &splitter, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Ascii(splitter, nfo, "BitM");
     }
-/*
+    /*
     "\nThumbNailHdrSize %ld"
     "\nThumbHeader: %02hx 02hx %02hx "
     "\nColorBufSize %ld"
@@ -845,222 +806,203 @@ void COBImporter::ReadBitM_Ascii(Scene& /*out*/, LineSplitter& splitter, const C
         Bitmap::BitmapHeader data;
         char opaq[sizeof Bitmap::BitmapHeader()];
     };*/
-//  ReadHexOctets(opaq,head,(++splitter)[1]);
+    //  ReadHexOctets(opaq,head,(++splitter)[1]);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadString_Binary(std::string& out, StreamReaderLE& reader)
-{
-    out.resize( reader.GetI2());
-    for(char& c : out) {
+void COBImporter::ReadString_Binary(std::string &out, StreamReaderLE &reader) {
+    out.resize(reader.GetI2());
+    for (char &c : out) {
         c = reader.GetI1();
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBasicNodeInfo_Binary(Node& msh, StreamReaderLE& reader, const ChunkInfo& /*nfo*/)
-{
+void COBImporter::ReadBasicNodeInfo_Binary(Node &msh, StreamReaderLE &reader, const ChunkInfo & /*nfo*/) {
     const unsigned int dupes = reader.GetI2();
-    ReadString_Binary(msh.name,reader);
+    ReadString_Binary(msh.name, reader);
 
-    msh.name = format(msh.name)<<'_'<<dupes;
+    msh.name = format(msh.name) << '_' << dupes;
 
     // skip local axes for the moment
     reader.IncPtr(48);
 
     msh.transform = aiMatrix4x4();
-    for(unsigned int y = 0; y < 3; ++y) {
-        for(unsigned int x =0; x < 4; ++x) {
+    for (unsigned int y = 0; y < 3; ++y) {
+        for (unsigned int x = 0; x < 4; ++x) {
             msh.transform[y][x] = reader.GetF4();
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::UnsupportedChunk_Binary( StreamReaderLE& reader, const ChunkInfo& nfo, const char* name)
-{
-    const std::string error = format("Encountered unsupported chunk: ") <<  name <<
-        " [version: "<<nfo.version<<", size: "<<nfo.size<<"]";
+void COBImporter::UnsupportedChunk_Binary(StreamReaderLE &reader, const ChunkInfo &nfo, const char *name) {
+    const std::string error = format("Encountered unsupported chunk: ") << name << " [version: " << nfo.version << ", size: " << nfo.size << "]";
 
     // we can recover if the chunk size was specified.
-    if(nfo.size != static_cast<unsigned int>(-1)) {
+    if (nfo.size != static_cast<unsigned int>(-1)) {
         ASSIMP_LOG_ERROR(error);
         reader.IncPtr(nfo.size);
-    }
-    else ThrowException(error);
+    } else
+        ThrowException(error);
 }
 
 // ------------------------------------------------------------------------------------------------
 // tiny utility guard to aid me at staying within chunk boundaries.
 class chunk_guard {
 public:
-    chunk_guard(const COB::ChunkInfo& nfo, StreamReaderLE& reader)
-    : nfo(nfo)
-    , reader(reader)
-    , cur(reader.GetCurrentPos()) {
+    chunk_guard(const COB::ChunkInfo &nfo, StreamReaderLE &reader) :
+            nfo(nfo), reader(reader), cur(reader.GetCurrentPos()) {
         // empty
     }
 
     ~chunk_guard() {
         // don't do anything if the size is not given
-        if(nfo.size != static_cast<unsigned int>(-1)) {
+        if (nfo.size != static_cast<unsigned int>(-1)) {
             try {
-                reader.IncPtr( static_cast< int >( nfo.size ) - reader.GetCurrentPos() + cur );
-            } catch (const DeadlyImportError& ) {
+                reader.IncPtr(static_cast<int>(nfo.size) - reader.GetCurrentPos() + cur);
+            } catch (const DeadlyImportError &) {
                 // out of limit so correct the value
-                reader.IncPtr( reader.GetReadLimit() );
+                reader.IncPtr(reader.GetReadLimit());
             }
         }
     }
 
 private:
-    const COB::ChunkInfo& nfo;
-    StreamReaderLE& reader;
+    const COB::ChunkInfo &nfo;
+    StreamReaderLE &reader;
     long cur;
 };
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBinaryFile(Scene& out, StreamReaderLE* reader) {
+void COBImporter::ReadBinaryFile(Scene &out, StreamReaderLE *reader) {
     if (nullptr == reader) {
         return;
     }
 
-    while(1) {
+    while (1) {
         std::string type;
-         type += reader -> GetI1()
-        ,type += reader -> GetI1()
-        ,type += reader -> GetI1()
-        ,type += reader -> GetI1()
-        ;
+        type += reader->GetI1(), type += reader->GetI1(), type += reader->GetI1(), type += reader->GetI1();
 
         ChunkInfo nfo;
-        nfo.version  = reader -> GetI2()*10;
-        nfo.version += reader -> GetI2();
+        nfo.version = reader->GetI2() * 10;
+        nfo.version += reader->GetI2();
 
         nfo.id = reader->GetI4();
         nfo.parent_id = reader->GetI4();
         nfo.size = reader->GetI4();
 
         if (type == "PolH") {
-            ReadPolH_Binary(out,*reader,nfo);
+            ReadPolH_Binary(out, *reader, nfo);
+        } else if (type == "BitM") {
+            ReadBitM_Binary(out, *reader, nfo);
+        } else if (type == "Grou") {
+            ReadGrou_Binary(out, *reader, nfo);
+        } else if (type == "Lght") {
+            ReadLght_Binary(out, *reader, nfo);
+        } else if (type == "Came") {
+            ReadCame_Binary(out, *reader, nfo);
+        } else if (type == "Mat1") {
+            ReadMat1_Binary(out, *reader, nfo);
         }
-        else if (type == "BitM") {
-            ReadBitM_Binary(out,*reader,nfo);
-        }
-        else if (type == "Grou") {
-            ReadGrou_Binary(out,*reader,nfo);
-        }
-        else if (type == "Lght") {
-            ReadLght_Binary(out,*reader,nfo);
-        }
-        else if (type == "Came") {
-            ReadCame_Binary(out,*reader,nfo);
-        }
-        else if (type == "Mat1") {
-            ReadMat1_Binary(out,*reader,nfo);
-        }
-    /*  else if (type == "Bone") {
+        /*  else if (type == "Bone") {
             ReadBone_Binary(out,*reader,nfo);
         }
         else if (type == "Chan") {
             ReadChan_Binary(out,*reader,nfo);
         }*/
         else if (type == "Unit") {
-            ReadUnit_Binary(out,*reader,nfo);
-        }
-        else if (type == "OLay") {
+            ReadUnit_Binary(out, *reader, nfo);
+        } else if (type == "OLay") {
             // ignore layer index silently.
-            if(nfo.size != static_cast<unsigned int>(-1) ) {
+            if (nfo.size != static_cast<unsigned int>(-1)) {
                 reader->IncPtr(nfo.size);
-            }
-            else return UnsupportedChunk_Binary(*reader,nfo,type.c_str());
-        }
-        else if (type == "END ") {
+            } else
+                return UnsupportedChunk_Binary(*reader, nfo, type.c_str());
+        } else if (type == "END ") {
             return;
-        }
-        else UnsupportedChunk_Binary(*reader,nfo,type.c_str());
+        } else
+            UnsupportedChunk_Binary(*reader, nfo, type.c_str());
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadPolH_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Binary(reader,nfo,"PolH");
+void COBImporter::ReadPolH_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Binary(reader, nfo, "PolH");
     }
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
-    Mesh& msh = (Mesh&)(*out.nodes.back().get());
+    Mesh &msh = (Mesh &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 
     msh.vertex_positions.resize(reader.GetI4());
-    for(aiVector3D& v : msh.vertex_positions) {
+    for (aiVector3D &v : msh.vertex_positions) {
         v.x = reader.GetF4();
         v.y = reader.GetF4();
         v.z = reader.GetF4();
     }
 
     msh.texture_coords.resize(reader.GetI4());
-    for(aiVector2D& v : msh.texture_coords) {
+    for (aiVector2D &v : msh.texture_coords) {
         v.x = reader.GetF4();
         v.y = reader.GetF4();
     }
 
     const size_t numf = reader.GetI4();
     msh.faces.reserve(numf);
-    for(size_t i = 0; i < numf; ++i) {
+    for (size_t i = 0; i < numf; ++i) {
         // XXX backface culling flag is 0x10 in flags
 
         // hole?
         bool hole = (reader.GetI1() & 0x08) != 0;
-        if ( hole ) {
+        if (hole) {
             // XXX Basically this should just work fine - then triangulator
             // should output properly triangulated data even for polygons
             // with holes. Test data specific to COB is needed to confirm it.
             if (msh.faces.empty()) {
                 ThrowException(format("A hole is the first entity in the `PolH` chunk with id ") << nfo.id);
             }
-        }
-        else msh.faces.push_back(Face());
-        Face& f = msh.faces.back();
+        } else
+            msh.faces.push_back(Face());
+        Face &f = msh.faces.back();
 
         const size_t num = reader.GetI2();
         f.indices.reserve(f.indices.size() + num);
 
-        if(!hole) {
+        if (!hole) {
             f.material = reader.GetI2();
             f.flags = 0;
         }
 
-        for(size_t x = 0; x < num; ++x) {
+        for (size_t x = 0; x < num; ++x) {
             f.indices.push_back(VertexIndex());
 
-            VertexIndex& v = f.indices.back();
+            VertexIndex &v = f.indices.back();
             v.pos_idx = reader.GetI4();
             v.uv_idx = reader.GetI4();
         }
 
-        if(hole) {
-            std::reverse(f.indices.rbegin(),f.indices.rbegin()+num);
+        if (hole) {
+            std::reverse(f.indices.rbegin(), f.indices.rbegin() + num);
         }
     }
-    if (nfo.version>4) {
+    if (nfo.version > 4) {
         msh.draw_flags = reader.GetI4();
     }
-    nfo.version>5 && nfo.version<8 ? reader.GetI4() : 0;
+    nfo.version > 5 && nfo.version < 8 ? reader.GetI4() : 0;
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadBitM_Binary(COB::Scene& /*out*/, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 1) {
-        return UnsupportedChunk_Binary(reader,nfo,"BitM");
+void COBImporter::ReadBitM_Binary(COB::Scene & /*out*/, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Binary(reader, nfo, "BitM");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     const uint32_t len = reader.GetI4();
     reader.IncPtr(len);
@@ -1070,47 +1012,46 @@ void COBImporter::ReadBitM_Binary(COB::Scene& /*out*/, StreamReaderLE& reader, c
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 8) {
-        return UnsupportedChunk_Binary(reader,nfo,"Mat1");
+void COBImporter::ReadMat1_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 8) {
+        return UnsupportedChunk_Binary(reader, nfo, "Mat1");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.materials.push_back(Material());
-    Material& mat = out.materials.back();
+    Material &mat = out.materials.back();
     mat = nfo;
 
     mat.matnum = reader.GetI2();
-    switch(reader.GetI1()) {
-        case 'f':
-            mat.type = Material::FLAT;
-            break;
-        case 'p':
-            mat.type = Material::PHONG;
-            break;
-        case 'm':
-            mat.type = Material::METAL;
-            break;
-        default:
-            ASSIMP_LOG_ERROR_F( "Unrecognized shader type in `Mat1` chunk with id ", nfo.id );
-            mat.type = Material::FLAT;
+    switch (reader.GetI1()) {
+    case 'f':
+        mat.type = Material::FLAT;
+        break;
+    case 'p':
+        mat.type = Material::PHONG;
+        break;
+    case 'm':
+        mat.type = Material::METAL;
+        break;
+    default:
+        ASSIMP_LOG_ERROR_F("Unrecognized shader type in `Mat1` chunk with id ", nfo.id);
+        mat.type = Material::FLAT;
     }
 
-    switch(reader.GetI1()) {
-        case 'f':
-            mat.autofacet = Material::FACETED;
-            break;
-        case 'a':
-            mat.autofacet = Material::AUTOFACETED;
-            break;
-        case 's':
-            mat.autofacet = Material::SMOOTH;
-            break;
-        default:
-            ASSIMP_LOG_ERROR_F( "Unrecognized faceting mode in `Mat1` chunk with id ", nfo.id );
-            mat.autofacet = Material::FACETED;
+    switch (reader.GetI1()) {
+    case 'f':
+        mat.autofacet = Material::FACETED;
+        break;
+    case 'a':
+        mat.autofacet = Material::AUTOFACETED;
+        break;
+    case 's':
+        mat.autofacet = Material::SMOOTH;
+        break;
+    default:
+        ASSIMP_LOG_ERROR_F("Unrecognized faceting mode in `Mat1` chunk with id ", nfo.id);
+        mat.autofacet = Material::FACETED;
     }
     mat.autofacet_angle = static_cast<float>(reader.GetI1());
 
@@ -1119,29 +1060,29 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
     mat.rgb.b = reader.GetF4();
 
     mat.alpha = reader.GetF4();
-    mat.ka    = reader.GetF4();
-    mat.ks    = reader.GetF4();
-    mat.exp   = reader.GetF4();
-    mat.ior   = reader.GetF4();
+    mat.ka = reader.GetF4();
+    mat.ks = reader.GetF4();
+    mat.exp = reader.GetF4();
+    mat.ior = reader.GetF4();
 
     char id[2];
-    id[0] = reader.GetI1(),id[1] = reader.GetI1();
+    id[0] = reader.GetI1(), id[1] = reader.GetI1();
 
     if (id[0] == 'e' && id[1] == ':') {
         mat.tex_env.reset(new Texture());
 
         reader.GetI1();
-        ReadString_Binary(mat.tex_env->path,reader);
+        ReadString_Binary(mat.tex_env->path, reader);
 
         // advance to next texture-id
-        id[0] = reader.GetI1(),id[1] = reader.GetI1();
+        id[0] = reader.GetI1(), id[1] = reader.GetI1();
     }
 
     if (id[0] == 't' && id[1] == ':') {
         mat.tex_color.reset(new Texture());
 
         reader.GetI1();
-        ReadString_Binary(mat.tex_color->path,reader);
+        ReadString_Binary(mat.tex_color->path, reader);
 
         mat.tex_color->transform.mTranslation.x = reader.GetF4();
         mat.tex_color->transform.mTranslation.y = reader.GetF4();
@@ -1150,14 +1091,14 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
         mat.tex_color->transform.mScaling.y = reader.GetF4();
 
         // advance to next texture-id
-        id[0] = reader.GetI1(),id[1] = reader.GetI1();
+        id[0] = reader.GetI1(), id[1] = reader.GetI1();
     }
 
     if (id[0] == 'b' && id[1] == ':') {
         mat.tex_bump.reset(new Texture());
 
         reader.GetI1();
-        ReadString_Binary(mat.tex_bump->path,reader);
+        ReadString_Binary(mat.tex_bump->path, reader);
 
         mat.tex_bump->transform.mTranslation.x = reader.GetF4();
         mat.tex_bump->transform.mTranslation.y = reader.GetF4();
@@ -1172,82 +1113,78 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadCame_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader,nfo,"Came");
+void COBImporter::ReadCame_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Binary(reader, nfo, "Came");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
-    Camera& msh = (Camera&)(*out.nodes.back().get());
+    Camera &msh = (Camera &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 
     // the rest is not interesting for us, so we skip over it.
-    if(nfo.version > 1) {
-        if (reader.GetI2()==512) {
+    if (nfo.version > 1) {
+        if (reader.GetI2() == 512) {
             reader.IncPtr(42);
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadLght_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader,nfo,"Lght");
+void COBImporter::ReadLght_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Binary(reader, nfo, "Lght");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::shared_ptr<Light>(new Light()));
-    Light& msh = (Light&)(*out.nodes.back().get());
+    Light &msh = (Light &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadGrou_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-    if(nfo.version > 2) {
-        return UnsupportedChunk_Binary(reader,nfo,"Grou");
+void COBImporter::ReadGrou_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 2) {
+        return UnsupportedChunk_Binary(reader, nfo, "Grou");
     }
 
-    const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     out.nodes.push_back(std::make_shared<Group>());
-    Group& msh = (Group&)(*out.nodes.back().get());
+    Group &msh = (Group &)(*out.nodes.back().get());
     msh = nfo;
 
-    ReadBasicNodeInfo_Binary(msh,reader,nfo);
+    ReadBasicNodeInfo_Binary(msh, reader, nfo);
 }
 
 // ------------------------------------------------------------------------------------------------
-void COBImporter::ReadUnit_Binary(COB::Scene& out, StreamReaderLE& reader, const ChunkInfo& nfo)
-{
-     if(nfo.version > 1) {
-        return UnsupportedChunk_Binary(reader,nfo,"Unit");
+void COBImporter::ReadUnit_Binary(COB::Scene &out, StreamReaderLE &reader, const ChunkInfo &nfo) {
+    if (nfo.version > 1) {
+        return UnsupportedChunk_Binary(reader, nfo, "Unit");
     }
 
-     const chunk_guard cn(nfo,reader);
+    const chunk_guard cn(nfo, reader);
 
     // parent chunks preceede their childs, so we should have the
     // corresponding chunk already.
-    for(std::shared_ptr< Node >& nd : out.nodes) {
+    for (std::shared_ptr<Node> &nd : out.nodes) {
         if (nd->id == nfo.parent_id) {
-            const unsigned int t=reader.GetI2();
-            nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(
-                ASSIMP_LOG_WARN_F(t," is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id)
-                ,1.f):units[t];
+            const unsigned int t = reader.GetI2();
+            nd->unit_scale = t >= sizeof(units) / sizeof(units[0]) ? (
+                                                                             ASSIMP_LOG_WARN_F(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id), 1.f) :
+                                                                     units[t];
 
             return;
         }
     }
-    ASSIMP_LOG_WARN_F( "`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
+    ASSIMP_LOG_WARN_F("`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
 }
 
 #endif // ASSIMP_BUILD_NO_COB_IMPORTER
diff --git a/code/COB/COBLoader.h b/code/AssetLib/COB/COBLoader.h
similarity index 100%
rename from code/COB/COBLoader.h
rename to code/AssetLib/COB/COBLoader.h
diff --git a/code/COB/COBScene.h b/code/AssetLib/COB/COBScene.h
similarity index 100%
rename from code/COB/COBScene.h
rename to code/AssetLib/COB/COBScene.h
diff --git a/code/CSM/CSMLoader.cpp b/code/AssetLib/CSM/CSMLoader.cpp
similarity index 100%
rename from code/CSM/CSMLoader.cpp
rename to code/AssetLib/CSM/CSMLoader.cpp
diff --git a/code/CSM/CSMLoader.h b/code/AssetLib/CSM/CSMLoader.h
similarity index 100%
rename from code/CSM/CSMLoader.h
rename to code/AssetLib/CSM/CSMLoader.h
diff --git a/code/AssetLib/Collada/ColladaExporter.cpp b/code/AssetLib/Collada/ColladaExporter.cpp
new file mode 100644
index 000000000..c2b71d00c
--- /dev/null
+++ b/code/AssetLib/Collada/ColladaExporter.cpp
@@ -0,0 +1,1651 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
+
+#include "ColladaExporter.h"
+#include <assimp/Bitmap.h>
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/MathFunctions.h>
+#include <assimp/SceneCombiner.h>
+#include <assimp/StringUtils.h>
+#include <assimp/XMLTools.h>
+#include <assimp/commonMetaData.h>
+#include <assimp/fast_atof.h>
+#include <assimp/scene.h>
+#include <assimp/Exporter.hpp>
+#include <assimp/IOSystem.hpp>
+
+#include <assimp/Exceptional.h>
+
+#include <ctime>
+#include <iostream>
+#include <memory>
+#include <set>
+#include <vector>
+
+using namespace Assimp;
+
+namespace Assimp {
+
+// ------------------------------------------------------------------------------------------------
+// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
+void ExportSceneCollada(const char *pFile, IOSystem *pIOSystem, const aiScene *pScene, const ExportProperties * /*pProperties*/) {
+    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
+    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
+
+    // invoke the exporter
+    ColladaExporter iDoTheExportThing(pScene, pIOSystem, path, file);
+
+    if (iDoTheExportThing.mOutput.fail()) {
+        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
+    }
+
+    // we're still here - export successfully completed. Write result to the given IOSYstem
+    std::unique_ptr<IOStream> outfile(pIOSystem->Open(pFile, "wt"));
+    if (outfile == nullptr) {
+        throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
+    }
+
+    // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
+    outfile->Write(iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()), 1);
+}
+
+} // end of namespace Assimp
+
+// ------------------------------------------------------------------------------------------------
+// Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
+static const std::string XMLIDEncode(const std::string &name) {
+    const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
+    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
+
+    if (name.length() == 0) {
+        return name;
+    }
+
+    std::stringstream idEncoded;
+
+    // xsd:ID must start with letter or underscore
+    if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) {
+        idEncoded << '_';
+    }
+
+    for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) {
+        // xsd:ID can only contain letters, digits, underscores, hyphens and periods
+        if (strchr(XML_ID_CHARS, *it) != nullptr) {
+            idEncoded << *it;
+        } else {
+            // Select placeholder character based on invalid character to prevent name collisions
+            idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT];
+        }
+    }
+
+    return idEncoded.str();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Constructor for a specific scene to export
+ColladaExporter::ColladaExporter(const aiScene *pScene, IOSystem *pIOSystem, const std::string &path, const std::string &file) :
+        mIOSystem(pIOSystem), mPath(path), mFile(file) {
+    // make sure that all formatting happens using the standard, C locale and not the user's current locale
+    mOutput.imbue(std::locale("C"));
+    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
+
+    mScene = pScene;
+    mSceneOwned = false;
+
+    // set up strings
+    endstr = "\n";
+
+    // start writing the file
+    WriteFile();
+}
+
+// ------------------------------------------------------------------------------------------------
+// Destructor
+ColladaExporter::~ColladaExporter() {
+    if (mSceneOwned) {
+        delete mScene;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Starts writing the contents
+void ColladaExporter::WriteFile() {
+    // write the DTD
+    mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
+    // COLLADA element start
+    mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
+    PushTag();
+
+    WriteTextures();
+    WriteHeader();
+
+    WriteCamerasLibrary();
+    WriteLightsLibrary();
+    WriteMaterials();
+    WriteGeometryLibrary();
+    WriteControllerLibrary();
+
+    WriteSceneLibrary();
+
+    // customized, Writes the animation library
+    WriteAnimationsLibrary();
+
+    // useless Collada fu at the end, just in case we haven't had enough indirections, yet.
+    mOutput << startstr << "<scene>" << endstr;
+    PushTag();
+    mOutput << startstr << "<instance_visual_scene url=\"#" + XMLIDEncode(mScene->mRootNode->mName.C_Str()) + "\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</scene>" << endstr;
+    PopTag();
+    mOutput << "</COLLADA>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the asset header
+void ColladaExporter::WriteHeader() {
+    static const ai_real epsilon = Math::getEpsilon<ai_real>();
+    static const aiQuaternion x_rot(aiMatrix3x3(
+            0, -1, 0,
+            1, 0, 0,
+            0, 0, 1));
+    static const aiQuaternion y_rot(aiMatrix3x3(
+            1, 0, 0,
+            0, 1, 0,
+            0, 0, 1));
+    static const aiQuaternion z_rot(aiMatrix3x3(
+            1, 0, 0,
+            0, 0, 1,
+            0, -1, 0));
+
+    static const unsigned int date_nb_chars = 20;
+    char date_str[date_nb_chars];
+    std::time_t date = std::time(NULL);
+    std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
+
+    aiVector3D scaling;
+    aiQuaternion rotation;
+    aiVector3D position;
+    mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
+    rotation.Normalize();
+
+    bool add_root_node = false;
+
+    ai_real scale = 1.0;
+    if (std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
+        scale = (ai_real)((((double)scaling.x) + ((double)scaling.y) + ((double)scaling.z)) / 3.0);
+    } else {
+        add_root_node = true;
+    }
+
+    std::string up_axis = "Y_UP";
+    if (rotation.Equal(x_rot, epsilon)) {
+        up_axis = "X_UP";
+    } else if (rotation.Equal(y_rot, epsilon)) {
+        up_axis = "Y_UP";
+    } else if (rotation.Equal(z_rot, epsilon)) {
+        up_axis = "Z_UP";
+    } else {
+        add_root_node = true;
+    }
+
+    if (!position.Equal(aiVector3D(0, 0, 0))) {
+        add_root_node = true;
+    }
+
+    if (mScene->mRootNode->mNumChildren == 0) {
+        add_root_node = true;
+    }
+
+    if (add_root_node) {
+        aiScene *scene;
+        SceneCombiner::CopyScene(&scene, mScene);
+
+        aiNode *root = new aiNode("Scene");
+
+        root->mNumChildren = 1;
+        root->mChildren = new aiNode *[root->mNumChildren];
+
+        root->mChildren[0] = scene->mRootNode;
+        scene->mRootNode->mParent = root;
+        scene->mRootNode = root;
+
+        mScene = scene;
+        mSceneOwned = true;
+
+        up_axis = "Y_UP";
+        scale = 1.0;
+    }
+
+    mOutput << startstr << "<asset>" << endstr;
+    PushTag();
+    mOutput << startstr << "<contributor>" << endstr;
+    PushTag();
+
+    // If no Scene metadata, use root node metadata
+    aiMetadata *meta = mScene->mMetaData;
+    if (nullptr == meta) {
+        meta = mScene->mRootNode->mMetaData;
+    }
+
+    aiString value;
+    if (!meta || !meta->Get("Author", value)) {
+        mOutput << startstr << "<author>"
+                << "Assimp"
+                << "</author>" << endstr;
+    } else {
+        mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
+    }
+
+    if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
+        mOutput << startstr << "<authoring_tool>"
+                << "Assimp Exporter"
+                << "</authoring_tool>" << endstr;
+    } else {
+        mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
+    }
+
+    if (meta) {
+        if (meta->Get("Comments", value)) {
+            mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
+        }
+        if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
+            mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
+        }
+        if (meta->Get("SourceData", value)) {
+            mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</contributor>" << endstr;
+
+    if (nullptr == meta || !meta->Get("Created", value)) {
+        mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
+    } else {
+        mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
+    }
+
+    // Modified date is always the date saved
+    mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
+
+    if (meta) {
+        if (meta->Get("Keywords", value)) {
+            mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
+        }
+        if (meta->Get("Revision", value)) {
+            mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
+        }
+        if (meta->Get("Subject", value)) {
+            mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
+        }
+        if (meta->Get("Title", value)) {
+            mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
+        }
+    }
+
+    mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
+    mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
+    PopTag();
+    mOutput << startstr << "</asset>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteTextures() {
+    static const unsigned int buffer_size = 1024;
+    char str[buffer_size];
+
+    if (mScene->HasTextures()) {
+        for (unsigned int i = 0; i < mScene->mNumTextures; i++) {
+            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
+            // so we just write the textures in the current directory.
+
+            aiTexture *texture = mScene->mTextures[i];
+            if (nullptr == texture) {
+                continue;
+            }
+
+            ASSIMP_itoa10(str, buffer_size, i + 1);
+
+            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char *)texture->achFormatHint);
+
+            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
+            if (outfile == NULL) {
+                throw DeadlyExportError("could not open output texture file: " + mPath + name);
+            }
+
+            if (texture->mHeight == 0) {
+                outfile->Write((void *)texture->pcData, texture->mWidth, 1);
+            } else {
+                Bitmap::Save(texture, outfile.get());
+            }
+
+            outfile->Flush();
+
+            textures.insert(std::make_pair(i, name));
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteCamerasLibrary() {
+    if (mScene->HasCameras()) {
+
+        mOutput << startstr << "<library_cameras>" << endstr;
+        PushTag();
+
+        for (size_t a = 0; a < mScene->mNumCameras; ++a)
+            WriteCamera(a);
+
+        PopTag();
+        mOutput << startstr << "</library_cameras>" << endstr;
+    }
+}
+
+void ColladaExporter::WriteCamera(size_t pIndex) {
+
+    const aiCamera *cam = mScene->mCameras[pIndex];
+    const std::string cameraName = XMLEscape(cam->mName.C_Str());
+    const std::string cameraId = XMLIDEncode(cam->mName.C_Str());
+
+    mOutput << startstr << "<camera id=\"" << cameraId << "-camera\" name=\"" << cameraName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<optics>" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    //assimp doesn't support the import of orthographic cameras! se we write
+    //always perspective
+    mOutput << startstr << "<perspective>" << endstr;
+    PushTag();
+    mOutput << startstr << "<xfov sid=\"xfov\">" << AI_RAD_TO_DEG(cam->mHorizontalFOV)
+            << "</xfov>" << endstr;
+    mOutput << startstr << "<aspect_ratio>"
+            << cam->mAspect
+            << "</aspect_ratio>" << endstr;
+    mOutput << startstr << "<znear sid=\"znear\">"
+            << cam->mClipPlaneNear
+            << "</znear>" << endstr;
+    mOutput << startstr << "<zfar sid=\"zfar\">"
+            << cam->mClipPlaneFar
+            << "</zfar>" << endstr;
+    PopTag();
+    mOutput << startstr << "</perspective>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</optics>" << endstr;
+    PopTag();
+    mOutput << startstr << "</camera>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Write the embedded textures
+void ColladaExporter::WriteLightsLibrary() {
+    if (mScene->HasLights()) {
+
+        mOutput << startstr << "<library_lights>" << endstr;
+        PushTag();
+
+        for (size_t a = 0; a < mScene->mNumLights; ++a)
+            WriteLight(a);
+
+        PopTag();
+        mOutput << startstr << "</library_lights>" << endstr;
+    }
+}
+
+void ColladaExporter::WriteLight(size_t pIndex) {
+
+    const aiLight *light = mScene->mLights[pIndex];
+    const std::string lightName = XMLEscape(light->mName.C_Str());
+    const std::string lightId = XMLIDEncode(light->mName.C_Str());
+
+    mOutput << startstr << "<light id=\"" << lightId << "-light\" name=\""
+            << lightName << "\" >" << endstr;
+    PushTag();
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    switch (light->mType) {
+    case aiLightSource_AMBIENT:
+        WriteAmbienttLight(light);
+        break;
+    case aiLightSource_DIRECTIONAL:
+        WriteDirectionalLight(light);
+        break;
+    case aiLightSource_POINT:
+        WritePointLight(light);
+        break;
+    case aiLightSource_SPOT:
+        WriteSpotLight(light);
+        break;
+    case aiLightSource_AREA:
+    case aiLightSource_UNDEFINED:
+    case _aiLightSource_Force32Bit:
+        break;
+    }
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</light>" << endstr;
+}
+
+void ColladaExporter::WritePointLight(const aiLight *const light) {
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<point>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+            << light->mAttenuationConstant
+            << "</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+            << light->mAttenuationLinear
+            << "</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+            << light->mAttenuationQuadratic
+            << "</quadratic_attenuation>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</point>" << endstr;
+}
+
+void ColladaExporter::WriteDirectionalLight(const aiLight *const light) {
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<directional>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</directional>" << endstr;
+}
+
+void ColladaExporter::WriteSpotLight(const aiLight *const light) {
+
+    const aiColor3D &color = light->mColorDiffuse;
+    mOutput << startstr << "<spot>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+    mOutput << startstr << "<constant_attenuation>"
+            << light->mAttenuationConstant
+            << "</constant_attenuation>" << endstr;
+    mOutput << startstr << "<linear_attenuation>"
+            << light->mAttenuationLinear
+            << "</linear_attenuation>" << endstr;
+    mOutput << startstr << "<quadratic_attenuation>"
+            << light->mAttenuationQuadratic
+            << "</quadratic_attenuation>" << endstr;
+    /*
+    out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
+                            srcLight->mFalloffAngle);
+    */
+
+    const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
+    mOutput << startstr << "<falloff_angle sid=\"fall_off_angle\">"
+            << fallOffAngle
+            << "</falloff_angle>" << endstr;
+    double temp = light->mAngleOuterCone - light->mAngleInnerCone;
+
+    temp = std::cos(temp);
+    temp = std::log(temp) / std::log(0.1);
+    temp = 1 / temp;
+    mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
+            << temp
+            << "</falloff_exponent>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</spot>" << endstr;
+}
+
+void ColladaExporter::WriteAmbienttLight(const aiLight *const light) {
+
+    const aiColor3D &color = light->mColorAmbient;
+    mOutput << startstr << "<ambient>" << endstr;
+    PushTag();
+    mOutput << startstr << "<color sid=\"color\">"
+            << color.r << " " << color.g << " " << color.b
+            << "</color>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</ambient>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reads a single surface entry from the given material keys
+void ColladaExporter::ReadMaterialSurface(Surface &poSurface, const aiMaterial *pSrcMat,
+        aiTextureType pTexture, const char *pKey, size_t pType, size_t pIndex) {
+    if (pSrcMat->GetTextureCount(pTexture) > 0) {
+        aiString texfile;
+        unsigned int uvChannel = 0;
+        pSrcMat->GetTexture(pTexture, 0, &texfile, NULL, &uvChannel);
+
+        std::string index_str(texfile.C_Str());
+
+        if (index_str.size() != 0 && index_str[0] == '*') {
+            unsigned int index;
+
+            index_str = index_str.substr(1, std::string::npos);
+
+            try {
+                index = (unsigned int)strtoul10_64(index_str.c_str());
+            } catch (std::exception &error) {
+                throw DeadlyExportError(error.what());
+            }
+
+            std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
+
+            if (name != textures.end()) {
+                poSurface.texture = name->second;
+            } else {
+                throw DeadlyExportError("could not find embedded texture at index " + index_str);
+            }
+        } else {
+            poSurface.texture = texfile.C_Str();
+        }
+
+        poSurface.channel = uvChannel;
+        poSurface.exist = true;
+    } else {
+        if (pKey)
+            poSurface.exist = pSrcMat->Get(pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Reimplementation of isalnum(,C locale), because AppVeyor does not see standard version.
+static bool isalnum_C(char c) {
+    return (nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz", c));
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes an image entry for the given surface
+void ColladaExporter::WriteImageEntry(const Surface &pSurface, const std::string &pNameAdd) {
+    if (!pSurface.texture.empty()) {
+        mOutput << startstr << "<image id=\"" << XMLIDEncode(pNameAdd) << "\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<init_from>";
+
+        // URL encode image file name first, then XML encode on top
+        std::stringstream imageUrlEncoded;
+        for (std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it) {
+            if (isalnum_C((unsigned char)*it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\')
+                imageUrlEncoded << *it;
+            else
+                imageUrlEncoded << '%' << std::hex << size_t((unsigned char)*it) << std::dec;
+        }
+        mOutput << XMLEscape(imageUrlEncoded.str());
+        mOutput << "</init_from>" << endstr;
+        PopTag();
+        mOutput << startstr << "</image>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a color-or-texture entry into an effect definition
+void ColladaExporter::WriteTextureColorEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &pImageName) {
+    if (pSurface.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        if (pSurface.texture.empty()) {
+            mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
+        } else {
+            mOutput << startstr << "<texture texture=\"" << XMLIDEncode(pImageName) << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the two parameters necessary for referencing a texture in an effect entry
+void ColladaExporter::WriteTextureParamEntry(const Surface &pSurface, const std::string &pTypeName, const std::string &pMatName) {
+    // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
+    if (!pSurface.texture.empty()) {
+        mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<surface type=\"2D\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<init_from>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-image</init_from>" << endstr;
+        PopTag();
+        mOutput << startstr << "</surface>" << endstr;
+        PopTag();
+        mOutput << startstr << "</newparam>" << endstr;
+
+        mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-sampler\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<sampler2D>" << endstr;
+        PushTag();
+        mOutput << startstr << "<source>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface</source>" << endstr;
+        PopTag();
+        mOutput << startstr << "</sampler2D>" << endstr;
+        PopTag();
+        mOutput << startstr << "</newparam>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a scalar property
+void ColladaExporter::WriteFloatEntry(const Property &pProperty, const std::string &pTypeName) {
+    if (pProperty.exist) {
+        mOutput << startstr << "<" << pTypeName << ">" << endstr;
+        PushTag();
+        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
+        PopTag();
+        mOutput << startstr << "</" << pTypeName << ">" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the material setup
+void ColladaExporter::WriteMaterials() {
+    materials.resize(mScene->mNumMaterials);
+
+    /// collect all materials from the scene
+    size_t numTextures = 0;
+    for (size_t a = 0; a < mScene->mNumMaterials; ++a) {
+        const aiMaterial *mat = mScene->mMaterials[a];
+
+        aiString name;
+        if (mat->Get(AI_MATKEY_NAME, name) != aiReturn_SUCCESS) {
+            name = "mat";
+            materials[a].name = std::string("m") + to_string(a) + name.C_Str();
+        } else {
+            // try to use the material's name if no other material has already taken it, else append #
+            std::string testName = name.C_Str();
+            size_t materialCountWithThisName = 0;
+            for (size_t i = 0; i < a; i++) {
+                if (materials[i].name == testName) {
+                    materialCountWithThisName++;
+                }
+            }
+            if (materialCountWithThisName == 0) {
+                materials[a].name = name.C_Str();
+            } else {
+                materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);
+            }
+        }
+
+        aiShadingMode shading = aiShadingMode_Flat;
+        materials[a].shading_model = "phong";
+        if (mat->Get(AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) {
+            if (shading == aiShadingMode_Phong) {
+                materials[a].shading_model = "phong";
+            } else if (shading == aiShadingMode_Blinn) {
+                materials[a].shading_model = "blinn";
+            } else if (shading == aiShadingMode_NoShading) {
+                materials[a].shading_model = "constant";
+            } else if (shading == aiShadingMode_Gouraud) {
+                materials[a].shading_model = "lambert";
+            }
+        }
+
+        ReadMaterialSurface(materials[a].ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT);
+        if (!materials[a].ambient.texture.empty()) numTextures++;
+        ReadMaterialSurface(materials[a].diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE);
+        if (!materials[a].diffuse.texture.empty()) numTextures++;
+        ReadMaterialSurface(materials[a].specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR);
+        if (!materials[a].specular.texture.empty()) numTextures++;
+        ReadMaterialSurface(materials[a].emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE);
+        if (!materials[a].emissive.texture.empty()) numTextures++;
+        ReadMaterialSurface(materials[a].reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE);
+        if (!materials[a].reflective.texture.empty()) numTextures++;
+        ReadMaterialSurface(materials[a].transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT);
+        if (!materials[a].transparent.texture.empty()) numTextures++;
+        ReadMaterialSurface(materials[a].normal, mat, aiTextureType_NORMALS, NULL, 0, 0);
+        if (!materials[a].normal.texture.empty()) numTextures++;
+
+        materials[a].shininess.exist = mat->Get(AI_MATKEY_SHININESS, materials[a].shininess.value) == aiReturn_SUCCESS;
+        materials[a].transparency.exist = mat->Get(AI_MATKEY_OPACITY, materials[a].transparency.value) == aiReturn_SUCCESS;
+        materials[a].index_refraction.exist = mat->Get(AI_MATKEY_REFRACTI, materials[a].index_refraction.value) == aiReturn_SUCCESS;
+    }
+
+    // output textures if present
+    if (numTextures > 0) {
+        mOutput << startstr << "<library_images>" << endstr;
+        PushTag();
+        for (std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+            const Material &mat = *it;
+            WriteImageEntry(mat.ambient, mat.name + "-ambient-image");
+            WriteImageEntry(mat.diffuse, mat.name + "-diffuse-image");
+            WriteImageEntry(mat.specular, mat.name + "-specular-image");
+            WriteImageEntry(mat.emissive, mat.name + "-emission-image");
+            WriteImageEntry(mat.reflective, mat.name + "-reflective-image");
+            WriteImageEntry(mat.transparent, mat.name + "-transparent-image");
+            WriteImageEntry(mat.normal, mat.name + "-normal-image");
+        }
+        PopTag();
+        mOutput << startstr << "</library_images>" << endstr;
+    }
+
+    // output effects - those are the actual carriers of information
+    if (!materials.empty()) {
+        mOutput << startstr << "<library_effects>" << endstr;
+        PushTag();
+        for (std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+            const Material &mat = *it;
+            // this is so ridiculous it must be right
+            mOutput << startstr << "<effect id=\"" << XMLIDEncode(mat.name) << "-fx\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<profile_COMMON>" << endstr;
+            PushTag();
+
+            // write sampler- and surface params for the texture entries
+            WriteTextureParamEntry(mat.emissive, "emission", mat.name);
+            WriteTextureParamEntry(mat.ambient, "ambient", mat.name);
+            WriteTextureParamEntry(mat.diffuse, "diffuse", mat.name);
+            WriteTextureParamEntry(mat.specular, "specular", mat.name);
+            WriteTextureParamEntry(mat.reflective, "reflective", mat.name);
+            WriteTextureParamEntry(mat.transparent, "transparent", mat.name);
+            WriteTextureParamEntry(mat.normal, "normal", mat.name);
+
+            mOutput << startstr << "<technique sid=\"standard\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<" << mat.shading_model << ">" << endstr;
+            PushTag();
+
+            WriteTextureColorEntry(mat.emissive, "emission", mat.name + "-emission-sampler");
+            WriteTextureColorEntry(mat.ambient, "ambient", mat.name + "-ambient-sampler");
+            WriteTextureColorEntry(mat.diffuse, "diffuse", mat.name + "-diffuse-sampler");
+            WriteTextureColorEntry(mat.specular, "specular", mat.name + "-specular-sampler");
+            WriteFloatEntry(mat.shininess, "shininess");
+            WriteTextureColorEntry(mat.reflective, "reflective", mat.name + "-reflective-sampler");
+            WriteTextureColorEntry(mat.transparent, "transparent", mat.name + "-transparent-sampler");
+            WriteFloatEntry(mat.transparency, "transparency");
+            WriteFloatEntry(mat.index_refraction, "index_of_refraction");
+
+            if (!mat.normal.texture.empty()) {
+                WriteTextureColorEntry(mat.normal, "bump", mat.name + "-normal-sampler");
+            }
+
+            PopTag();
+            mOutput << startstr << "</" << mat.shading_model << ">" << endstr;
+            PopTag();
+            mOutput << startstr << "</technique>" << endstr;
+            PopTag();
+            mOutput << startstr << "</profile_COMMON>" << endstr;
+            PopTag();
+            mOutput << startstr << "</effect>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</library_effects>" << endstr;
+
+        // write materials - they're just effect references
+        mOutput << startstr << "<library_materials>" << endstr;
+        PushTag();
+        for (std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it) {
+            const Material &mat = *it;
+            mOutput << startstr << "<material id=\"" << XMLIDEncode(mat.name) << "\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
+            PushTag();
+            mOutput << startstr << "<instance_effect url=\"#" << XMLIDEncode(mat.name) << "-fx\"/>" << endstr;
+            PopTag();
+            mOutput << startstr << "</material>" << endstr;
+        }
+        PopTag();
+        mOutput << startstr << "</library_materials>" << endstr;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the controller library
+void ColladaExporter::WriteControllerLibrary() {
+    mOutput << startstr << "<library_controllers>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a) {
+        WriteController(a);
+    }
+
+    PopTag();
+    mOutput << startstr << "</library_controllers>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a skin controller of the given mesh
+void ColladaExporter::WriteController(size_t pIndex) {
+    const aiMesh *mesh = mScene->mMeshes[pIndex];
+    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
+    const std::string idstrEscaped = XMLIDEncode(idstr);
+
+    if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+        return;
+
+    if (mesh->mNumBones == 0)
+        return;
+
+    mOutput << startstr << "<controller id=\"" << idstrEscaped << "-skin\" ";
+    mOutput << "name=\"skinCluster" << pIndex << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<skin source=\"#" << idstrEscaped << "\">" << endstr;
+    PushTag();
+
+    // bind pose matrix
+    mOutput << startstr << "<bind_shape_matrix>" << endstr;
+    PushTag();
+
+    // I think it is identity in general cases.
+    aiMatrix4x4 mat;
+    mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr;
+    mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr;
+    mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr;
+    mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr;
+
+    PopTag();
+    mOutput << startstr << "</bind_shape_matrix>" << endstr;
+
+    mOutput << startstr << "<source id=\"" << idstrEscaped << "-skin-joints\" name=\"" << idstrEscaped << "-skin-joints\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<Name_array id=\"" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
+
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        mOutput << XMLIDEncode(mesh->mBones[i]->mName.C_Str()) << " ";
+
+    mOutput << "</Name_array>" << endstr;
+
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<accessor source=\"#" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+
+    std::vector<ai_real> bind_poses;
+    bind_poses.reserve(mesh->mNumBones * 16);
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for (unsigned int j = 0; j < 4; ++j)
+            bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
+
+    WriteFloatArray(idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real *)bind_poses.data(), bind_poses.size() / 16);
+
+    bind_poses.clear();
+
+    std::vector<ai_real> skin_weights;
+    skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
+
+    WriteFloatArray(idstr + "-skin-weights", FloatType_Weight, (const ai_real *)skin_weights.data(), skin_weights.size());
+
+    skin_weights.clear();
+
+    mOutput << startstr << "<joints>" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstrEscaped << "-skin-bind_poses\"></input>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</joints>" << endstr;
+
+    mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\" offset=\"0\"></input>" << endstr;
+    mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstrEscaped << "-skin-weights\" offset=\"1\"></input>" << endstr;
+
+    mOutput << startstr << "<vcount>";
+
+    std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
+    for (size_t i = 0; i < mesh->mNumBones; ++i)
+        for (size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
+            ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
+
+    for (size_t i = 0; i < mesh->mNumVertices; ++i)
+        mOutput << num_influences[i] << " ";
+
+    mOutput << "</vcount>" << endstr;
+
+    mOutput << startstr << "<v>";
+
+    ai_uint joint_weight_indices_length = 0;
+    std::vector<ai_uint> accum_influences;
+    accum_influences.reserve(num_influences.size());
+    for (size_t i = 0; i < num_influences.size(); ++i) {
+        accum_influences.push_back(joint_weight_indices_length);
+        joint_weight_indices_length += num_influences[i];
+    }
+
+    ai_uint weight_index = 0;
+    std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
+    for (unsigned int i = 0; i < mesh->mNumBones; ++i)
+        for (unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j) {
+            unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
+            for (ai_uint k = 0; k < num_influences[vId]; ++k) {
+                if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1) {
+                    joint_weight_indices[2 * (accum_influences[vId] + k)] = i;
+                    joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index;
+                    break;
+                }
+            }
+            ++weight_index;
+        }
+
+    for (size_t i = 0; i < joint_weight_indices.size(); ++i)
+        mOutput << joint_weight_indices[i] << " ";
+
+    num_influences.clear();
+    accum_influences.clear();
+    joint_weight_indices.clear();
+
+    mOutput << "</v>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</vertex_weights>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</skin>" << endstr;
+
+    PopTag();
+    mOutput << startstr << "</controller>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the geometry library
+void ColladaExporter::WriteGeometryLibrary() {
+    mOutput << startstr << "<library_geometries>" << endstr;
+    PushTag();
+
+    for (size_t a = 0; a < mScene->mNumMeshes; ++a)
+        WriteGeometry(a);
+
+    PopTag();
+    mOutput << startstr << "</library_geometries>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the given mesh
+void ColladaExporter::WriteGeometry(size_t pIndex) {
+    const aiMesh *mesh = mScene->mMeshes[pIndex];
+    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
+    const std::string geometryName = XMLEscape(idstr);
+    const std::string geometryId = XMLIDEncode(idstr);
+
+    if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+        return;
+
+    // opening tag
+    mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
+    PushTag();
+
+    mOutput << startstr << "<mesh>" << endstr;
+    PushTag();
+
+    // Positions
+    WriteFloatArray(idstr + "-positions", FloatType_Vector, (ai_real *)mesh->mVertices, mesh->mNumVertices);
+    // Normals, if any
+    if (mesh->HasNormals())
+        WriteFloatArray(idstr + "-normals", FloatType_Vector, (ai_real *)mesh->mNormals, mesh->mNumVertices);
+
+    // texture coords
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (mesh->HasTextureCoords(static_cast<unsigned int>(a))) {
+            WriteFloatArray(idstr + "-tex" + to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
+                    (ai_real *)mesh->mTextureCoords[a], mesh->mNumVertices);
+        }
+    }
+
+    // vertex colors
+    for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+        if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+            WriteFloatArray(idstr + "-color" + to_string(a), FloatType_Color, (ai_real *)mesh->mColors[a], mesh->mNumVertices);
+    }
+
+    // assemble vertex structure
+    // Only write input for POSITION since we will write other as shared inputs in polygon definition
+    mOutput << startstr << "<vertices id=\"" << geometryId << "-vertices"
+            << "\">" << endstr;
+    PushTag();
+    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
+    PopTag();
+    mOutput << startstr << "</vertices>" << endstr;
+
+    // count the number of lines, triangles and polygon meshes
+    int countLines = 0;
+    int countPoly = 0;
+    for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+        if (mesh->mFaces[a].mNumIndices == 2)
+            countLines++;
+        else if (mesh->mFaces[a].mNumIndices >= 3)
+            countPoly++;
+    }
+
+    // lines
+    if (countLines) {
+        mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if (mesh->HasNormals())
+            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+            if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+
+        mOutput << startstr << "<p>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            const aiFace &face = mesh->mFaces[a];
+            if (face.mNumIndices != 2) continue;
+            for (size_t b = 0; b < face.mNumIndices; ++b)
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</lines>" << endstr;
+    }
+
+    // triangle - don't use it, because compatibility problems
+
+    // polygons
+    if (countPoly) {
+        mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
+        PushTag();
+        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
+        if (mesh->HasNormals())
+            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
+            if (mesh->HasTextureCoords(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+        for (size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
+            if (mesh->HasVertexColors(static_cast<unsigned int>(a)))
+                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" "
+                        << "set=\"" << a << "\""
+                        << " />" << endstr;
+        }
+
+        mOutput << startstr << "<vcount>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            if (mesh->mFaces[a].mNumIndices < 3) continue;
+            mOutput << mesh->mFaces[a].mNumIndices << " ";
+        }
+        mOutput << "</vcount>" << endstr;
+
+        mOutput << startstr << "<p>";
+        for (size_t a = 0; a < mesh->mNumFaces; ++a) {
+            const aiFace &face = mesh->mFaces[a];
+            if (face.mNumIndices < 3) continue;
+            for (size_t b = 0; b < face.mNumIndices; ++b)
+                mOutput << face.mIndices[b] << " ";
+        }
+        mOutput << "</p>" << endstr;
+        PopTag();
+        mOutput << startstr << "</polylist>" << endstr;
+    }
+
+    // closing tags
+    PopTag();
+    mOutput << startstr << "</mesh>" << endstr;
+    PopTag();
+    mOutput << startstr << "</geometry>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes a float array of the given type
+void ColladaExporter::WriteFloatArray(const std::string &pIdString, FloatDataType pType, const ai_real *pData, size_t pElementCount) {
+    size_t floatsPerElement = 0;
+    switch (pType) {
+    case FloatType_Vector: floatsPerElement = 3; break;
+    case FloatType_TexCoord2: floatsPerElement = 2; break;
+    case FloatType_TexCoord3: floatsPerElement = 3; break;
+    case FloatType_Color: floatsPerElement = 3; break;
+    case FloatType_Mat4x4: floatsPerElement = 16; break;
+    case FloatType_Weight: floatsPerElement = 1; break;
+    case FloatType_Time: floatsPerElement = 1; break;
+    default:
+        return;
+    }
+
+    std::string arrayId = XMLIDEncode(pIdString) + "-array";
+
+    mOutput << startstr << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
+    PushTag();
+
+    // source array
+    mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
+    PushTag();
+
+    if (pType == FloatType_TexCoord2) {
+        for (size_t a = 0; a < pElementCount; ++a) {
+            mOutput << pData[a * 3 + 0] << " ";
+            mOutput << pData[a * 3 + 1] << " ";
+        }
+    } else if (pType == FloatType_Color) {
+        for (size_t a = 0; a < pElementCount; ++a) {
+            mOutput << pData[a * 4 + 0] << " ";
+            mOutput << pData[a * 4 + 1] << " ";
+            mOutput << pData[a * 4 + 2] << " ";
+        }
+    } else {
+        for (size_t a = 0; a < pElementCount * floatsPerElement; ++a)
+            mOutput << pData[a] << " ";
+    }
+    mOutput << "</float_array>" << endstr;
+    PopTag();
+
+    // the usual Collada fun. Let's bloat it even more!
+    mOutput << startstr << "<technique_common>" << endstr;
+    PushTag();
+    mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
+    PushTag();
+
+    switch (pType) {
+    case FloatType_Vector:
+        mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_TexCoord2:
+        mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_TexCoord3:
+        mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_Color:
+        mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
+        mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
+        break;
+
+    case FloatType_Mat4x4:
+        mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
+        break;
+
+    case FloatType_Weight:
+        mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
+        break;
+
+    // customized, add animation related
+    case FloatType_Time:
+        mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
+        break;
+    }
+
+    PopTag();
+    mOutput << startstr << "</accessor>" << endstr;
+    PopTag();
+    mOutput << startstr << "</technique_common>" << endstr;
+    PopTag();
+    mOutput << startstr << "</source>" << endstr;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Writes the scene library
+void ColladaExporter::WriteSceneLibrary() {
+    const std::string sceneName = XMLEscape(mScene->mRootNode->mName.C_Str());
+    const std::string sceneId = XMLIDEncode(mScene->mRootNode->mName.C_Str());
+
+    mOutput << startstr << "<library_visual_scenes>" << endstr;
+    PushTag();
+    mOutput << startstr << "<visual_scene id=\"" + sceneId + "\" name=\"" + sceneName + "\">" << endstr;
+    PushTag();
+
+    // start recursive write at the root node
+    for (size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a)
+        WriteNode(mScene, mScene->mRootNode->mChildren[a]);
+
+    PopTag();
+    mOutput << startstr << "</visual_scene>" << endstr;
+    PopTag();
+    mOutput << startstr << "</library_visual_scenes>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationLibrary(size_t pIndex) {
+    const aiAnimation *anim = mScene->mAnimations[pIndex];
+
+    if (anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels == 0)
+        return;
+
+    const std::string animation_name_escaped = XMLEscape(anim->mName.C_Str());
+    std::string idstr = anim->mName.C_Str();
+    std::string ending = std::string("AnimId") + to_string(pIndex);
+    if (idstr.length() >= ending.length()) {
+        if (0 != idstr.compare(idstr.length() - ending.length(), ending.length(), ending)) {
+            idstr = idstr + ending;
+        }
+    } else {
+        idstr = idstr + ending;
+    }
+
+    const std::string idstrEscaped = XMLIDEncode(idstr);
+
+    mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animation_name_escaped + "\">" << endstr;
+    PushTag();
+
+    std::string cur_node_idstr;
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        // sanity check
+        if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) {
+            continue;
+        }
+
+        {
+            cur_node_idstr.clear();
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-input");
+
+            std::vector<ai_real> frames;
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                frames.push_back(static_cast<ai_real>(nodeAnim->mPositionKeys[i].mTime));
+            }
+
+            WriteFloatArray(cur_node_idstr, FloatType_Time, (const ai_real *)frames.data(), frames.size());
+            frames.clear();
+        }
+
+        {
+            cur_node_idstr.clear();
+
+            cur_node_idstr += nodeAnim->mNodeName.data;
+            cur_node_idstr += std::string("_matrix-output");
+
+            std::vector<ai_real> keyframes;
+            keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
+                aiMatrix4x4 ScalingM; // identity
+                ScalingM[0][0] = Scaling.x;
+                ScalingM[1][1] = Scaling.y;
+                ScalingM[2][2] = Scaling.z;
+
+                aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
+                aiMatrix4x4 s = aiMatrix4x4(RotationQ.GetMatrix());
+                aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
+
+                aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
+                aiMatrix4x4 TranslationM; // identity
+                TranslationM[0][3] = Translation.x;
+                TranslationM[1][3] = Translation.y;
+                TranslationM[2][3] = Translation.z;
+
+                // Combine the above transformations
+                aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
+
+                for (unsigned int j = 0; j < 4; ++j) {
+                    keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
+                }
+            }
+
+            WriteFloatArray(cur_node_idstr, FloatType_Mat4x4, (const ai_real *)keyframes.data(), keyframes.size() / 16);
+        }
+
+        {
+            std::vector<std::string> names;
+            for (size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
+                if (nodeAnim->mPreState == aiAnimBehaviour_DEFAULT || nodeAnim->mPreState == aiAnimBehaviour_LINEAR || nodeAnim->mPreState == aiAnimBehaviour_REPEAT) {
+                    names.push_back("LINEAR");
+                } else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
+                    names.push_back("STEP");
+                }
+            }
+
+            const std::string cur_node_idstr2 = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
+            std::string arrayId = XMLIDEncode(cur_node_idstr2) + "-array";
+
+            mOutput << startstr << "<source id=\"" << XMLIDEncode(cur_node_idstr2) << "\">" << endstr;
+            PushTag();
+
+            // source array
+            mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
+            for (size_t aa = 0; aa < names.size(); ++aa) {
+                mOutput << names[aa] << " ";
+            }
+            mOutput << "</Name_array>" << endstr;
+
+            mOutput << startstr << "<technique_common>" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</accessor>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</technique_common>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</source>" << endstr;
+        }
+    }
+
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        {
+            // samplers
+            const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
+            mOutput << startstr << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
+            PushTag();
+
+            mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-input")) << "\"/>" << endstr;
+            mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-output")) << "\"/>" << endstr;
+            mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-interpolation")) << "\"/>" << endstr;
+
+            PopTag();
+            mOutput << startstr << "</sampler>" << endstr;
+        }
+    }
+
+    for (size_t a = 0; a < anim->mNumChannels; ++a) {
+        const aiNodeAnim *nodeAnim = anim->mChannels[a];
+
+        {
+            // channels
+            mOutput << startstr << "<channel source=\"#" << XMLIDEncode(nodeAnim->mNodeName.data + std::string("_matrix-sampler")) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
+        }
+    }
+
+    PopTag();
+    mOutput << startstr << "</animation>" << endstr;
+}
+// ------------------------------------------------------------------------------------------------
+void ColladaExporter::WriteAnimationsLibrary() {
+    if (mScene->mNumAnimations > 0) {
+        mOutput << startstr << "<library_animations>" << endstr;
+        PushTag();
+
+        // start recursive write at the root node
+        for (size_t a = 0; a < mScene->mNumAnimations; ++a)
+            WriteAnimationLibrary(a);
+
+        PopTag();
+        mOutput << startstr << "</library_animations>" << endstr;
+    }
+}
+// ------------------------------------------------------------------------------------------------
+// Helper to find a bone by name in the scene
+aiBone *findBone(const aiScene *scene, const char *name) {
+    for (size_t m = 0; m < scene->mNumMeshes; m++) {
+        aiMesh *mesh = scene->mMeshes[m];
+        for (size_t b = 0; b < mesh->mNumBones; b++) {
+            aiBone *bone = mesh->mBones[b];
+            if (0 == strcmp(name, bone->mName.C_Str())) {
+                return bone;
+            }
+        }
+    }
+    return NULL;
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiNode *findBoneNode(const aiNode *aNode, const aiBone *bone) {
+    if (aNode && bone && aNode->mName == bone->mName) {
+        return aNode;
+    }
+
+    if (aNode && bone) {
+        for (unsigned int i = 0; i < aNode->mNumChildren; ++i) {
+            aiNode *aChild = aNode->mChildren[i];
+            const aiNode *foundFromChild = 0;
+            if (aChild) {
+                foundFromChild = findBoneNode(aChild, bone);
+                if (foundFromChild) return foundFromChild;
+            }
+        }
+    }
+
+    return NULL;
+}
+
+const aiNode *findSkeletonRootNode(const aiScene *scene, const aiMesh *mesh) {
+    std::set<const aiNode *> topParentBoneNodes;
+    if (mesh && mesh->mNumBones > 0) {
+        for (unsigned int i = 0; i < mesh->mNumBones; ++i) {
+            aiBone *bone = mesh->mBones[i];
+
+            const aiNode *node = findBoneNode(scene->mRootNode, bone);
+            if (node) {
+                while (node->mParent && findBone(scene, node->mParent->mName.C_Str()) != 0) {
+                    node = node->mParent;
+                }
+                topParentBoneNodes.insert(node);
+            }
+        }
+    }
+
+    if (!topParentBoneNodes.empty()) {
+        const aiNode *parentBoneNode = *topParentBoneNodes.begin();
+        if (topParentBoneNodes.size() == 1) {
+            return parentBoneNode;
+        } else {
+            for (auto it : topParentBoneNodes) {
+                if (it->mParent) return it->mParent;
+            }
+            return parentBoneNode;
+        }
+    }
+
+    return NULL;
+}
+
+// ------------------------------------------------------------------------------------------------
+// Recursively writes the given node
+void ColladaExporter::WriteNode(const aiScene *pScene, aiNode *pNode) {
+    // the node must have a name
+    if (pNode->mName.length == 0) {
+        std::stringstream ss;
+        ss << "Node_" << pNode;
+        pNode->mName.Set(ss.str());
+    }
+
+    // If the node is associated with a bone, it is a joint node (JOINT)
+    // otherwise it is a normal node (NODE)
+    const char *node_type;
+    bool is_joint, is_skeleton_root = false;
+    if (nullptr == findBone(pScene, pNode->mName.C_Str())) {
+        node_type = "NODE";
+        is_joint = false;
+    } else {
+        node_type = "JOINT";
+        is_joint = true;
+        if (!pNode->mParent || nullptr == findBone(pScene, pNode->mParent->mName.C_Str())) {
+            is_skeleton_root = true;
+        }
+    }
+
+    const std::string node_id = XMLIDEncode(pNode->mName.data);
+    const std::string node_name = XMLEscape(pNode->mName.data);
+    mOutput << startstr << "<node ";
+    if (is_skeleton_root) {
+        mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id + "\"" : ""); // For now, only support one skeleton in a scene.
+        mFoundSkeletonRootNodeID = node_id;
+    } else {
+        mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id + "\"" : "");
+    }
+
+    mOutput << " name=\"" << node_name
+            << "\" type=\"" << node_type
+            << "\">" << endstr;
+    PushTag();
+
+    // write transformation - we can directly put the matrix there
+    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
+    aiMatrix4x4 mat = pNode->mTransformation;
+
+    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
+    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
+    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
+    // coordinate system must be changed to matche the Collada specification.
+    for (size_t i = 0; i < mScene->mNumCameras; i++) {
+        if (mScene->mCameras[i]->mName == pNode->mName) {
+            aiMatrix4x4 sourceView;
+            mScene->mCameras[i]->GetCameraMatrix(sourceView);
+
+            aiMatrix4x4 colladaView;
+            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
+            mat *= (sourceView * colladaView);
+            break;
+        }
+    }
+
+    // customized, sid should be 'matrix' to match with loader code.
+    //mOutput << startstr << "<matrix sid=\"transform\">";
+    mOutput << startstr << "<matrix sid=\"matrix\">";
+
+    mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
+    mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
+    mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
+    mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
+    mOutput << "</matrix>" << endstr;
+
+    if (pNode->mNumMeshes == 0) {
+        //check if it is a camera node
+        for (size_t i = 0; i < mScene->mNumCameras; i++) {
+            if (mScene->mCameras[i]->mName == pNode->mName) {
+                mOutput << startstr << "<instance_camera url=\"#" << node_id << "-camera\"/>" << endstr;
+                break;
+            }
+        }
+        //check if it is a light node
+        for (size_t i = 0; i < mScene->mNumLights; i++) {
+            if (mScene->mLights[i]->mName == pNode->mName) {
+                mOutput << startstr << "<instance_light url=\"#" << node_id << "-light\"/>" << endstr;
+                break;
+            }
+        }
+
+    } else
+        // instance every geometry
+        for (size_t a = 0; a < pNode->mNumMeshes; ++a) {
+            const aiMesh *mesh = mScene->mMeshes[pNode->mMeshes[a]];
+            // do not instantiate mesh if empty. I wonder how this could happen
+            if (mesh->mNumFaces == 0 || mesh->mNumVertices == 0)
+                continue;
+
+            const std::string meshName = mesh->mName.length == 0 ? GetMeshId(pNode->mMeshes[a]) : mesh->mName.C_Str();
+
+            if (mesh->mNumBones == 0) {
+                mOutput << startstr << "<instance_geometry url=\"#" << XMLIDEncode(meshName) << "\">" << endstr;
+                PushTag();
+            } else {
+                mOutput << startstr
+                        << "<instance_controller url=\"#" << XMLIDEncode(meshName) << "-skin\">"
+                        << endstr;
+                PushTag();
+
+                // note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
+                // use the first bone to find skeleton root
+                const aiNode *skeletonRootBoneNode = findSkeletonRootNode(pScene, mesh);
+                if (skeletonRootBoneNode) {
+                    mFoundSkeletonRootNodeID = XMLIDEncode(skeletonRootBoneNode->mName.C_Str());
+                }
+                mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
+            }
+            mOutput << startstr << "<bind_material>" << endstr;
+            PushTag();
+            mOutput << startstr << "<technique_common>" << endstr;
+            PushTag();
+            mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << XMLIDEncode(materials[mesh->mMaterialIndex].name) << "\">" << endstr;
+            PushTag();
+            for (size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa) {
+                if (mesh->HasTextureCoords(static_cast<unsigned int>(aa)))
+                    // semantic       as in <texture texcoord=...>
+                    // input_semantic as in <input semantic=...>
+                    // input_set      as in <input set=...>
+                    mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << aa << "\" input_semantic=\"TEXCOORD\" input_set=\"" << aa << "\"/>" << endstr;
+            }
+            PopTag();
+            mOutput << startstr << "</instance_material>" << endstr;
+            PopTag();
+            mOutput << startstr << "</technique_common>" << endstr;
+            PopTag();
+            mOutput << startstr << "</bind_material>" << endstr;
+
+            PopTag();
+            if (mesh->mNumBones == 0)
+                mOutput << startstr << "</instance_geometry>" << endstr;
+            else
+                mOutput << startstr << "</instance_controller>" << endstr;
+        }
+
+    // recurse into subnodes
+    for (size_t a = 0; a < pNode->mNumChildren; ++a)
+        WriteNode(pScene, pNode->mChildren[a]);
+
+    PopTag();
+    mOutput << startstr << "</node>" << endstr;
+}
+
+#endif
+#endif
diff --git a/code/Collada/ColladaExporter.h b/code/AssetLib/Collada/ColladaExporter.h
similarity index 100%
rename from code/Collada/ColladaExporter.h
rename to code/AssetLib/Collada/ColladaExporter.h
diff --git a/code/Collada/ColladaHelper.cpp b/code/AssetLib/Collada/ColladaHelper.cpp
similarity index 100%
rename from code/Collada/ColladaHelper.cpp
rename to code/AssetLib/Collada/ColladaHelper.cpp
diff --git a/code/Collada/ColladaHelper.h b/code/AssetLib/Collada/ColladaHelper.h
similarity index 100%
rename from code/Collada/ColladaHelper.h
rename to code/AssetLib/Collada/ColladaHelper.h
diff --git a/code/Collada/ColladaLoader.cpp b/code/AssetLib/Collada/ColladaLoader.cpp
similarity index 100%
rename from code/Collada/ColladaLoader.cpp
rename to code/AssetLib/Collada/ColladaLoader.cpp
diff --git a/code/Collada/ColladaLoader.h b/code/AssetLib/Collada/ColladaLoader.h
similarity index 100%
rename from code/Collada/ColladaLoader.h
rename to code/AssetLib/Collada/ColladaLoader.h
diff --git a/code/Collada/ColladaParser.cpp b/code/AssetLib/Collada/ColladaParser.cpp
similarity index 100%
rename from code/Collada/ColladaParser.cpp
rename to code/AssetLib/Collada/ColladaParser.cpp
diff --git a/code/Collada/ColladaParser.h b/code/AssetLib/Collada/ColladaParser.h
similarity index 100%
rename from code/Collada/ColladaParser.h
rename to code/AssetLib/Collada/ColladaParser.h
diff --git a/code/DXF/DXFHelper.h b/code/AssetLib/DXF/DXFHelper.h
similarity index 100%
rename from code/DXF/DXFHelper.h
rename to code/AssetLib/DXF/DXFHelper.h
diff --git a/code/DXF/DXFLoader.cpp b/code/AssetLib/DXF/DXFLoader.cpp
similarity index 99%
rename from code/DXF/DXFLoader.cpp
rename to code/AssetLib/DXF/DXFLoader.cpp
index ea877a484..bd5c23c7b 100644
--- a/code/DXF/DXFLoader.cpp
+++ b/code/AssetLib/DXF/DXFLoader.cpp
@@ -48,8 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
 
-#include "DXF/DXFLoader.h"
-#include "DXF/DXFHelper.h"
+#include "AssetLib/DXF/DXFLoader.h"
+#include "AssetLib/DXF/DXFHelper.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/ParsingUtils.h>
diff --git a/code/DXF/DXFLoader.h b/code/AssetLib/DXF/DXFLoader.h
similarity index 100%
rename from code/DXF/DXFLoader.h
rename to code/AssetLib/DXF/DXFLoader.h
diff --git a/code/FBX/FBXAnimation.cpp b/code/AssetLib/FBX/FBXAnimation.cpp
similarity index 100%
rename from code/FBX/FBXAnimation.cpp
rename to code/AssetLib/FBX/FBXAnimation.cpp
diff --git a/code/FBX/FBXBinaryTokenizer.cpp b/code/AssetLib/FBX/FBXBinaryTokenizer.cpp
similarity index 100%
rename from code/FBX/FBXBinaryTokenizer.cpp
rename to code/AssetLib/FBX/FBXBinaryTokenizer.cpp
diff --git a/code/FBX/FBXCommon.h b/code/AssetLib/FBX/FBXCommon.h
similarity index 100%
rename from code/FBX/FBXCommon.h
rename to code/AssetLib/FBX/FBXCommon.h
diff --git a/code/FBX/FBXCompileConfig.h b/code/AssetLib/FBX/FBXCompileConfig.h
similarity index 100%
rename from code/FBX/FBXCompileConfig.h
rename to code/AssetLib/FBX/FBXCompileConfig.h
diff --git a/code/FBX/FBXConverter.cpp b/code/AssetLib/FBX/FBXConverter.cpp
similarity index 100%
rename from code/FBX/FBXConverter.cpp
rename to code/AssetLib/FBX/FBXConverter.cpp
diff --git a/code/FBX/FBXConverter.h b/code/AssetLib/FBX/FBXConverter.h
similarity index 100%
rename from code/FBX/FBXConverter.h
rename to code/AssetLib/FBX/FBXConverter.h
diff --git a/code/FBX/FBXDeformer.cpp b/code/AssetLib/FBX/FBXDeformer.cpp
similarity index 100%
rename from code/FBX/FBXDeformer.cpp
rename to code/AssetLib/FBX/FBXDeformer.cpp
diff --git a/code/FBX/FBXDocument.cpp b/code/AssetLib/FBX/FBXDocument.cpp
similarity index 100%
rename from code/FBX/FBXDocument.cpp
rename to code/AssetLib/FBX/FBXDocument.cpp
diff --git a/code/FBX/FBXDocument.h b/code/AssetLib/FBX/FBXDocument.h
similarity index 100%
rename from code/FBX/FBXDocument.h
rename to code/AssetLib/FBX/FBXDocument.h
diff --git a/code/FBX/FBXDocumentUtil.cpp b/code/AssetLib/FBX/FBXDocumentUtil.cpp
similarity index 100%
rename from code/FBX/FBXDocumentUtil.cpp
rename to code/AssetLib/FBX/FBXDocumentUtil.cpp
diff --git a/code/FBX/FBXDocumentUtil.h b/code/AssetLib/FBX/FBXDocumentUtil.h
similarity index 100%
rename from code/FBX/FBXDocumentUtil.h
rename to code/AssetLib/FBX/FBXDocumentUtil.h
diff --git a/code/FBX/FBXExportNode.cpp b/code/AssetLib/FBX/FBXExportNode.cpp
similarity index 100%
rename from code/FBX/FBXExportNode.cpp
rename to code/AssetLib/FBX/FBXExportNode.cpp
diff --git a/code/FBX/FBXExportNode.h b/code/AssetLib/FBX/FBXExportNode.h
similarity index 100%
rename from code/FBX/FBXExportNode.h
rename to code/AssetLib/FBX/FBXExportNode.h
diff --git a/code/FBX/FBXExportProperty.cpp b/code/AssetLib/FBX/FBXExportProperty.cpp
similarity index 100%
rename from code/FBX/FBXExportProperty.cpp
rename to code/AssetLib/FBX/FBXExportProperty.cpp
diff --git a/code/FBX/FBXExportProperty.h b/code/AssetLib/FBX/FBXExportProperty.h
similarity index 100%
rename from code/FBX/FBXExportProperty.h
rename to code/AssetLib/FBX/FBXExportProperty.h
diff --git a/code/FBX/FBXExporter.cpp b/code/AssetLib/FBX/FBXExporter.cpp
similarity index 100%
rename from code/FBX/FBXExporter.cpp
rename to code/AssetLib/FBX/FBXExporter.cpp
diff --git a/code/FBX/FBXExporter.h b/code/AssetLib/FBX/FBXExporter.h
similarity index 100%
rename from code/FBX/FBXExporter.h
rename to code/AssetLib/FBX/FBXExporter.h
diff --git a/code/FBX/FBXImportSettings.h b/code/AssetLib/FBX/FBXImportSettings.h
similarity index 100%
rename from code/FBX/FBXImportSettings.h
rename to code/AssetLib/FBX/FBXImportSettings.h
diff --git a/code/FBX/FBXImporter.cpp b/code/AssetLib/FBX/FBXImporter.cpp
similarity index 100%
rename from code/FBX/FBXImporter.cpp
rename to code/AssetLib/FBX/FBXImporter.cpp
diff --git a/code/FBX/FBXImporter.h b/code/AssetLib/FBX/FBXImporter.h
similarity index 100%
rename from code/FBX/FBXImporter.h
rename to code/AssetLib/FBX/FBXImporter.h
diff --git a/code/FBX/FBXMaterial.cpp b/code/AssetLib/FBX/FBXMaterial.cpp
similarity index 100%
rename from code/FBX/FBXMaterial.cpp
rename to code/AssetLib/FBX/FBXMaterial.cpp
diff --git a/code/FBX/FBXMeshGeometry.cpp b/code/AssetLib/FBX/FBXMeshGeometry.cpp
similarity index 100%
rename from code/FBX/FBXMeshGeometry.cpp
rename to code/AssetLib/FBX/FBXMeshGeometry.cpp
diff --git a/code/FBX/FBXMeshGeometry.h b/code/AssetLib/FBX/FBXMeshGeometry.h
similarity index 100%
rename from code/FBX/FBXMeshGeometry.h
rename to code/AssetLib/FBX/FBXMeshGeometry.h
diff --git a/code/FBX/FBXModel.cpp b/code/AssetLib/FBX/FBXModel.cpp
similarity index 100%
rename from code/FBX/FBXModel.cpp
rename to code/AssetLib/FBX/FBXModel.cpp
diff --git a/code/FBX/FBXNodeAttribute.cpp b/code/AssetLib/FBX/FBXNodeAttribute.cpp
similarity index 100%
rename from code/FBX/FBXNodeAttribute.cpp
rename to code/AssetLib/FBX/FBXNodeAttribute.cpp
diff --git a/code/FBX/FBXParser.cpp b/code/AssetLib/FBX/FBXParser.cpp
similarity index 100%
rename from code/FBX/FBXParser.cpp
rename to code/AssetLib/FBX/FBXParser.cpp
diff --git a/code/FBX/FBXParser.h b/code/AssetLib/FBX/FBXParser.h
similarity index 100%
rename from code/FBX/FBXParser.h
rename to code/AssetLib/FBX/FBXParser.h
diff --git a/code/FBX/FBXProperties.cpp b/code/AssetLib/FBX/FBXProperties.cpp
similarity index 100%
rename from code/FBX/FBXProperties.cpp
rename to code/AssetLib/FBX/FBXProperties.cpp
diff --git a/code/FBX/FBXProperties.h b/code/AssetLib/FBX/FBXProperties.h
similarity index 100%
rename from code/FBX/FBXProperties.h
rename to code/AssetLib/FBX/FBXProperties.h
diff --git a/code/FBX/FBXTokenizer.cpp b/code/AssetLib/FBX/FBXTokenizer.cpp
similarity index 100%
rename from code/FBX/FBXTokenizer.cpp
rename to code/AssetLib/FBX/FBXTokenizer.cpp
diff --git a/code/FBX/FBXTokenizer.h b/code/AssetLib/FBX/FBXTokenizer.h
similarity index 100%
rename from code/FBX/FBXTokenizer.h
rename to code/AssetLib/FBX/FBXTokenizer.h
diff --git a/code/FBX/FBXUtil.cpp b/code/AssetLib/FBX/FBXUtil.cpp
similarity index 100%
rename from code/FBX/FBXUtil.cpp
rename to code/AssetLib/FBX/FBXUtil.cpp
diff --git a/code/FBX/FBXUtil.h b/code/AssetLib/FBX/FBXUtil.h
similarity index 100%
rename from code/FBX/FBXUtil.h
rename to code/AssetLib/FBX/FBXUtil.h
diff --git a/code/HMP/HMPFileData.h b/code/AssetLib/HMP/HMPFileData.h
similarity index 100%
rename from code/HMP/HMPFileData.h
rename to code/AssetLib/HMP/HMPFileData.h
diff --git a/code/HMP/HMPLoader.cpp b/code/AssetLib/HMP/HMPLoader.cpp
similarity index 99%
rename from code/HMP/HMPLoader.cpp
rename to code/AssetLib/HMP/HMPLoader.cpp
index 0dea09ee0..54eb395bd 100644
--- a/code/HMP/HMPLoader.cpp
+++ b/code/AssetLib/HMP/HMPLoader.cpp
@@ -47,8 +47,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
 
 // internal headers
-#include "HMP/HMPLoader.h"
-#include "MD2/MD2FileData.h"
+#include "AssetLib/HMP/HMPLoader.h"
+#include "AssetLib/MD2/MD2FileData.h"
 
 #include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
diff --git a/code/HMP/HMPLoader.h b/code/AssetLib/HMP/HMPLoader.h
similarity index 98%
rename from code/HMP/HMPLoader.h
rename to code/AssetLib/HMP/HMPLoader.h
index 0371a608b..2995c1237 100644
--- a/code/HMP/HMPLoader.h
+++ b/code/AssetLib/HMP/HMPLoader.h
@@ -49,8 +49,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include <assimp/BaseImporter.h>
 
-#include "MDL/MDLLoader.h"
-#include "HMP/HMPFileData.h"
+#include "AssetLib/MDL/MDLLoader.h"
+#include "AssetLib/HMP/HMPFileData.h"
 
 namespace Assimp {
 using namespace HMP;
diff --git a/code/HMP/HalfLifeFileData.h b/code/AssetLib/HMP/HalfLifeFileData.h
similarity index 100%
rename from code/HMP/HalfLifeFileData.h
rename to code/AssetLib/HMP/HalfLifeFileData.h
diff --git a/code/Importer/IFC/IFCBoolean.cpp b/code/AssetLib/IFC/IFCBoolean.cpp
similarity index 74%
rename from code/Importer/IFC/IFCBoolean.cpp
rename to code/AssetLib/IFC/IFCBoolean.cpp
index 01fd43cd2..2c9f6cf8f 100644
--- a/code/Importer/IFC/IFCBoolean.cpp
+++ b/code/AssetLib/IFC/IFCBoolean.cpp
@@ -43,65 +43,60 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#include "code/Importer/IFC/IFCUtil.h"
-#include "code/Common/PolyTools.h"
-#include "code/PostProcessing/ProcessHelper.h"
+
+#include "AssetLib/IFC/IFCUtil.h"
+#include "Common/PolyTools.h"
+#include "PostProcessing/ProcessHelper.h"
+
 #include <assimp/Defines.h>
 
 #include <iterator>
 #include <tuple>
 
 namespace Assimp {
-    namespace IFC {
+namespace IFC {
 
 // ------------------------------------------------------------------------------------------------
 // Calculates intersection between line segment and plane. To catch corner cases, specify which side you prefer.
 // The function then generates a hit only if the end is beyond a certain margin in that direction, filtering out
 // "very close to plane" ghost hits as long as start and end stay directly on or within the given plane side.
-bool IntersectSegmentPlane(const IfcVector3& p,const IfcVector3& n, const IfcVector3& e0,
-        const IfcVector3& e1, bool assumeStartOnWhiteSide, IfcVector3& out)
-{
+bool IntersectSegmentPlane(const IfcVector3 &p, const IfcVector3 &n, const IfcVector3 &e0,
+        const IfcVector3 &e1, bool assumeStartOnWhiteSide, IfcVector3 &out) {
     const IfcVector3 pdelta = e0 - p, seg = e1 - e0;
-    const IfcFloat dotOne = n*seg, dotTwo = -(n*pdelta);
+    const IfcFloat dotOne = n * seg, dotTwo = -(n * pdelta);
 
     // if segment ends on plane, do not report a hit. We stay on that side until a following segment starting at this
     // point leaves the plane through the other side
-    if( std::abs(dotOne + dotTwo) < 1e-6 )
+    if (std::abs(dotOne + dotTwo) < 1e-6)
         return false;
 
     // if segment starts on the plane, report a hit only if the end lies on the *other* side
-    if( std::abs(dotTwo) < 1e-6 )
-    {
-        if( (assumeStartOnWhiteSide && dotOne + dotTwo < 1e-6) || (!assumeStartOnWhiteSide && dotOne + dotTwo > -1e-6) )
-        {
+    if (std::abs(dotTwo) < 1e-6) {
+        if ((assumeStartOnWhiteSide && dotOne + dotTwo < 1e-6) || (!assumeStartOnWhiteSide && dotOne + dotTwo > -1e-6)) {
             out = e0;
             return true;
-        }
-        else
-        {
+        } else {
             return false;
         }
     }
 
     // ignore if segment is parallel to plane and far away from it on either side
     // Warning: if there's a few thousand of such segments which slowly accumulate beyond the epsilon, no hit would be registered
-    if( std::abs(dotOne) < 1e-6 )
+    if (std::abs(dotOne) < 1e-6)
         return false;
 
     // t must be in [0..1] if the intersection point is within the given segment
     const IfcFloat t = dotTwo / dotOne;
-    if( t > 1.0 || t < 0.0 )
+    if (t > 1.0 || t < 0.0)
         return false;
 
-    out = e0 + t*seg;
+    out = e0 + t * seg;
     return true;
 }
 
 // ------------------------------------------------------------------------------------------------
-void FilterPolygon(std::vector<IfcVector3>& resultpoly)
-{
-    if( resultpoly.size() < 3 )
-    {
+void FilterPolygon(std::vector<IfcVector3> &resultpoly) {
+    if (resultpoly.size() < 3) {
         resultpoly.clear();
         return;
     }
@@ -115,87 +110,80 @@ void FilterPolygon(std::vector<IfcVector3>& resultpoly)
     FuzzyVectorCompare fz(epsilon);
     std::vector<IfcVector3>::iterator e = std::unique(resultpoly.begin(), resultpoly.end(), fz);
 
-    if( e != resultpoly.end() )
+    if (e != resultpoly.end())
         resultpoly.erase(e, resultpoly.end());
 
-    if( !resultpoly.empty() && fz(resultpoly.front(), resultpoly.back()) )
+    if (!resultpoly.empty() && fz(resultpoly.front(), resultpoly.back()))
         resultpoly.pop_back();
 }
 
 // ------------------------------------------------------------------------------------------------
-void WritePolygon(std::vector<IfcVector3>& resultpoly, TempMesh& result)
-{
+void WritePolygon(std::vector<IfcVector3> &resultpoly, TempMesh &result) {
     FilterPolygon(resultpoly);
 
-    if( resultpoly.size() > 2 )
-    {
+    if (resultpoly.size() > 2) {
         result.mVerts.insert(result.mVerts.end(), resultpoly.begin(), resultpoly.end());
         result.mVertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs, TempMesh& result,
-    const TempMesh& first_operand,
-    ConversionData& /*conv*/)
-{
+void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid *hs, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData & /*conv*/) {
     ai_assert(hs != NULL);
 
-    const Schema_2x3::IfcPlane* const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
-    if(!plane) {
+    const Schema_2x3::IfcPlane *const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
+    if (!plane) {
         IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
         return;
     }
 
     // extract plane base position vector and normal vector
-    IfcVector3 p,n(0.f,0.f,1.f);
+    IfcVector3 p, n(0.f, 0.f, 1.f);
     if (plane->Position->Axis) {
-        ConvertDirection(n,plane->Position->Axis.Get());
+        ConvertDirection(n, plane->Position->Axis.Get());
     }
-    ConvertCartesianPoint(p,plane->Position->Location);
+    ConvertCartesianPoint(p, plane->Position->Location);
 
-    if(!IsTrue(hs->AgreementFlag)) {
+    if (!IsTrue(hs->AgreementFlag)) {
         n *= -1.f;
     }
 
     // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3>& in = first_operand.mVerts;
-    std::vector<IfcVector3>& outvert = result.mVerts;
+    const std::vector<IfcVector3> &in = first_operand.mVerts;
+    std::vector<IfcVector3> &outvert = result.mVerts;
 
     std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin(),
-        end = first_operand.mVertcnt.end(), iit;
+                                              end = first_operand.mVertcnt.end(), iit;
 
     outvert.reserve(in.size());
     result.mVertcnt.reserve(first_operand.mVertcnt.size());
 
     unsigned int vidx = 0;
-    for(iit = begin; iit != end; vidx += *iit++) {
+    for (iit = begin; iit != end; vidx += *iit++) {
 
         unsigned int newcount = 0;
         bool isAtWhiteSide = (in[vidx] - p) * n > -1e-6;
-        for( unsigned int i = 0; i < *iit; ++i ) {
-            const IfcVector3& e0 = in[vidx + i], e1 = in[vidx + (i + 1) % *iit];
+        for (unsigned int i = 0; i < *iit; ++i) {
+            const IfcVector3 &e0 = in[vidx + i], e1 = in[vidx + (i + 1) % *iit];
 
             // does the next segment intersect the plane?
             IfcVector3 isectpos;
-            if( IntersectSegmentPlane(p, n, e0, e1, isAtWhiteSide, isectpos) ) {
-                if( isAtWhiteSide ) {
+            if (IntersectSegmentPlane(p, n, e0, e1, isAtWhiteSide, isectpos)) {
+                if (isAtWhiteSide) {
                     // e0 is on the right side, so keep it
                     outvert.push_back(e0);
                     outvert.push_back(isectpos);
                     newcount += 2;
-                }
-                else {
+                } else {
                     // e0 is on the wrong side, so drop it and keep e1 instead
                     outvert.push_back(isectpos);
                     ++newcount;
                 }
                 isAtWhiteSide = !isAtWhiteSide;
-            }
-            else
-            {
-                if( isAtWhiteSide ) {
+            } else {
+                if (isAtWhiteSide) {
                     outvert.push_back(e0);
                     ++newcount;
                 }
@@ -206,33 +194,32 @@ void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs,
             continue;
         }
 
-        IfcVector3 vmin,vmax;
-        ArrayBounds(&*(outvert.end()-newcount),newcount,vmin,vmax);
+        IfcVector3 vmin, vmax;
+        ArrayBounds(&*(outvert.end() - newcount), newcount, vmin, vmax);
 
         // filter our IfcFloat points - those may happen if a point lies
         // directly on the intersection line. However, due to IfcFloat
         // precision a bitwise comparison is not feasible to detect
         // this case.
-        const IfcFloat epsilon = (vmax-vmin).SquareLength() / 1e6f;
+        const IfcFloat epsilon = (vmax - vmin).SquareLength() / 1e6f;
         FuzzyVectorCompare fz(epsilon);
 
-        std::vector<IfcVector3>::iterator e = std::unique( outvert.end()-newcount, outvert.end(), fz );
+        std::vector<IfcVector3>::iterator e = std::unique(outvert.end() - newcount, outvert.end(), fz);
 
         if (e != outvert.end()) {
-            newcount -= static_cast<unsigned int>(std::distance(e,outvert.end()));
-            outvert.erase(e,outvert.end());
+            newcount -= static_cast<unsigned int>(std::distance(e, outvert.end()));
+            outvert.erase(e, outvert.end());
         }
-        if (fz(*( outvert.end()-newcount),outvert.back())) {
+        if (fz(*(outvert.end() - newcount), outvert.back())) {
             outvert.pop_back();
             --newcount;
         }
-        if(newcount > 2) {
+        if (newcount > 2) {
             result.mVertcnt.push_back(newcount);
-        }
-        else while(newcount-->0) {
-            result.mVerts.pop_back();
-        }
-
+        } else
+            while (newcount-- > 0) {
+                result.mVerts.pop_back();
+            }
     }
     IFCImporter::LogDebug("generating CSG geometry by plane clipping (IfcBooleanClippingResult)");
 }
@@ -244,37 +231,36 @@ void ProcessBooleanHalfSpaceDifference(const Schema_2x3::IfcHalfSpaceSolid* hs,
 // the line stays on that side. This should make corner cases more stable.
 // Two million assumptions! Boundary should have all z at 0.0, will be treated as closed, should not have
 // segments with length <1e-6, self-intersecting might break the corner case handling... just don't go there, ok?
-bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const std::vector<IfcVector3>& boundary,
-    const bool isStartAssumedInside, std::vector<std::pair<size_t, IfcVector3> >& intersect_results,
-    const bool halfOpen = false)
-{
+bool IntersectsBoundaryProfile(const IfcVector3 &e0, const IfcVector3 &e1, const std::vector<IfcVector3> &boundary,
+        const bool isStartAssumedInside, std::vector<std::pair<size_t, IfcVector3>> &intersect_results,
+        const bool halfOpen = false) {
     ai_assert(intersect_results.empty());
 
     // determine winding order - necessary to detect segments going "inwards" or "outwards" from a point directly on the border
     // positive sum of angles means clockwise order when looking down the -Z axis
     IfcFloat windingOrder = 0.0;
-    for( size_t i = 0, bcount = boundary.size(); i < bcount; ++i ) {
+    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
         IfcVector3 b01 = boundary[(i + 1) % bcount] - boundary[i];
         IfcVector3 b12 = boundary[(i + 2) % bcount] - boundary[(i + 1) % bcount];
         IfcVector3 b1_side = IfcVector3(b01.y, -b01.x, 0.0); // rotated 90° clockwise in Z plane
         // Warning: rough estimate only. A concave poly with lots of small segments each featuring a small counter rotation
         // could fool the accumulation. Correct implementation would be sum( acos( b01 * b2) * sign( b12 * b1_side))
-        windingOrder += (b1_side.x*b12.x + b1_side.y*b12.y);
+        windingOrder += (b1_side.x * b12.x + b1_side.y * b12.y);
     }
     windingOrder = windingOrder > 0.0 ? 1.0 : -1.0;
 
     const IfcVector3 e = e1 - e0;
 
-    for( size_t i = 0, bcount = boundary.size(); i < bcount; ++i ) {
+    for (size_t i = 0, bcount = boundary.size(); i < bcount; ++i) {
         // boundary segment i: b0-b1
-        const IfcVector3& b0 = boundary[i];
-        const IfcVector3& b1 = boundary[(i + 1) % bcount];
+        const IfcVector3 &b0 = boundary[i];
+        const IfcVector3 &b1 = boundary[(i + 1) % bcount];
         IfcVector3 b = b1 - b0;
 
         // segment-segment intersection
         // solve b0 + b*s = e0 + e*t for (s,t)
         const IfcFloat det = (-b.x * e.y + e.x * b.y);
-        if( std::abs(det) < 1e-6 ) {
+        if (std::abs(det) < 1e-6) {
             // no solutions (parallel lines)
             continue;
         }
@@ -282,11 +268,11 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
 
         const IfcFloat x = b0.x - e0.x;
         const IfcFloat y = b0.y - e0.y;
-        const IfcFloat s = (x*e.y - e.x*y) / det; // scale along boundary edge
-        const IfcFloat t = (x*b.y - b.x*y) / det; // scale along given segment
-        const IfcVector3 p = e0 + e*t;
+        const IfcFloat s = (x * e.y - e.x * y) / det; // scale along boundary edge
+        const IfcFloat t = (x * b.y - b.x * y) / det; // scale along given segment
+        const IfcVector3 p = e0 + e * t;
 #ifdef ASSIMP_BUILD_DEBUG
-        const IfcVector3 check = b0 + b*s - p;
+        const IfcVector3 check = b0 + b * s - p;
         ai_assert((IfcVector2(check.x, check.y)).SquareLength() < 1e-5);
 #endif
 
@@ -296,35 +282,33 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
         {
             // calculate closest point to each end on the segment, clamp that point to the segment's length, then check
             // distance to that point. This approach is like testing if e0 is inside a capped cylinder.
-            IfcFloat et0 = (b.x*(e0.x - b0.x) + b.y*(e0.y - b0.y)) * b_sqlen_inv;
+            IfcFloat et0 = (b.x * (e0.x - b0.x) + b.y * (e0.y - b0.y)) * b_sqlen_inv;
             IfcVector3 closestPosToE0OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et0)) * b;
             startsAtSegment = (closestPosToE0OnBoundary - IfcVector3(e0.x, e0.y, 0.0)).SquareLength() < 1e-12;
-            IfcFloat et1 = (b.x*(e1.x - b0.x) + b.y*(e1.y - b0.y)) * b_sqlen_inv;
+            IfcFloat et1 = (b.x * (e1.x - b0.x) + b.y * (e1.y - b0.y)) * b_sqlen_inv;
             IfcVector3 closestPosToE1OnBoundary = b0 + std::max(IfcFloat(0.0), std::min(IfcFloat(1.0), et1)) * b;
             endsAtSegment = (closestPosToE1OnBoundary - IfcVector3(e1.x, e1.y, 0.0)).SquareLength() < 1e-12;
         }
 
         // Line segment ends at boundary -> ignore any hit, it will be handled by possibly following segments
-        if( endsAtSegment && !halfOpen )
+        if (endsAtSegment && !halfOpen)
             continue;
 
         // Line segment starts at boundary -> generate a hit only if following that line would change the INSIDE/OUTSIDE
         // state. This should catch the case where a connected set of segments has a point directly on the boundary,
         // one segment not hitting it because it ends there and the next segment not hitting it because it starts there
         // Should NOT generate a hit if the segment only touches the boundary but turns around and stays inside.
-        if( startsAtSegment )
-        {
+        if (startsAtSegment) {
             IfcVector3 inside_dir = IfcVector3(b.y, -b.x, 0.0) * windingOrder;
             bool isGoingInside = (inside_dir * e) > 0.0;
-            if( isGoingInside == isStartAssumedInside )
+            if (isGoingInside == isStartAssumedInside)
                 continue;
 
             // only insert the point into the list if it is sufficiently far away from the previous intersection point.
             // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
-            if( !intersect_results.empty() && intersect_results.back().first == i - 1 )
-            {
+            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
                 const IfcVector3 diff = intersect_results.back().second - e0;
-                if( IfcVector2(diff.x, diff.y).SquareLength() < 1e-10 )
+                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
                     continue;
             }
             intersect_results.push_back(std::make_pair(i, e0));
@@ -333,14 +317,12 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
 
         // for a valid intersection, s and t should be in range [0,1]. Including a bit of epsilon on s, potential double
         // hits on two consecutive boundary segments are filtered
-        if( s >= -1e-6 * b_sqlen_inv && s <= 1.0 + 1e-6*b_sqlen_inv && t >= 0.0 && (t <= 1.0 || halfOpen) )
-        {
+        if (s >= -1e-6 * b_sqlen_inv && s <= 1.0 + 1e-6 * b_sqlen_inv && t >= 0.0 && (t <= 1.0 || halfOpen)) {
             // only insert the point into the list if it is sufficiently far away from the previous intersection point.
             // This way, we avoid duplicate detection if the intersection is directly on the vertex between two segments.
-            if( !intersect_results.empty() && intersect_results.back().first == i - 1 )
-            {
+            if (!intersect_results.empty() && intersect_results.back().first == i - 1) {
                 const IfcVector3 diff = intersect_results.back().second - p;
-                if( IfcVector2(diff.x, diff.y).SquareLength() < 1e-10 )
+                if (IfcVector2(diff.x, diff.y).SquareLength() < 1e-10)
                     continue;
             }
             intersect_results.push_back(std::make_pair(i, p));
@@ -350,11 +332,9 @@ bool IntersectsBoundaryProfile(const IfcVector3& e0, const IfcVector3& e1, const
     return !intersect_results.empty();
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // note: this functions works on 3D vectors, but performs its intersection checks solely in xy.
-bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
-{
+bool PointInPoly(const IfcVector3 &p, const std::vector<IfcVector3> &boundary) {
     // even-odd algorithm: take a random vector that extends from p to infinite
     // and counts how many times it intersects edges of the boundary.
     // because checking for segment intersections is prone to numeric inaccuracies
@@ -365,7 +345,7 @@ bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
     // the border of the polygon. If any of our attempts produces this result,
     // we return false immediately.
 
-    std::vector<std::pair<size_t, IfcVector3> > intersected_boundary;
+    std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
     size_t votes = 0;
 
     IntersectsBoundaryProfile(p, p + IfcVector3(1.0, 0, 0), boundary, true, intersected_boundary, true);
@@ -382,28 +362,26 @@ bool PointInPoly(const IfcVector3& p, const std::vector<IfcVector3>& boundary)
     return votes > 1;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace* hs, TempMesh& result,
-                                                       const TempMesh& first_operand,
-                                                       ConversionData& conv)
-{
+void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPolygonalBoundedHalfSpace *hs, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData &conv) {
     ai_assert(hs != NULL);
 
-    const Schema_2x3::IfcPlane* const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
-    if(!plane) {
+    const Schema_2x3::IfcPlane *const plane = hs->BaseSurface->ToPtr<Schema_2x3::IfcPlane>();
+    if (!plane) {
         IFCImporter::LogError("expected IfcPlane as base surface for the IfcHalfSpaceSolid");
         return;
     }
 
     // extract plane base position vector and normal vector
-    IfcVector3 p,n(0.f,0.f,1.f);
+    IfcVector3 p, n(0.f, 0.f, 1.f);
     if (plane->Position->Axis) {
-        ConvertDirection(n,plane->Position->Axis.Get());
+        ConvertDirection(n, plane->Position->Axis.Get());
     }
-    ConvertCartesianPoint(p,plane->Position->Location);
+    ConvertCartesianPoint(p, plane->Position->Location);
 
-    if(!IsTrue(hs->AgreementFlag)) {
+    if (!IsTrue(hs->AgreementFlag)) {
         n *= -1.f;
     }
 
@@ -411,7 +389,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
 
     // obtain the polygonal bounding volume
     std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
-    if(!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
+    if (!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
         IFCImporter::LogError("expected valid polyline for boundary of boolean halfspace");
         return;
     }
@@ -420,7 +398,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
     IfcVector3 profileNormal = TempMesh::ComputePolygonNormal(profile->mVerts.data(), profile->mVerts.size());
 
     IfcMatrix4 proj_inv;
-    ConvertAxisPlacement(proj_inv,hs->Position);
+    ConvertAxisPlacement(proj_inv, hs->Position);
 
     // and map everything into a plane coordinate space so all intersection
     // tests can be done in 2D space.
@@ -428,9 +406,9 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
     proj.Inverse();
 
     // clip the current contents of `meshout` against the plane we obtained from the second operand
-    const std::vector<IfcVector3>& in = first_operand.mVerts;
-    std::vector<IfcVector3>& outvert = result.mVerts;
-    std::vector<unsigned int>& outvertcnt = result.mVertcnt;
+    const std::vector<IfcVector3> &in = first_operand.mVerts;
+    std::vector<IfcVector3> &outvert = result.mVerts;
+    std::vector<unsigned int> &outvertcnt = result.mVertcnt;
 
     outvert.reserve(in.size());
     outvertcnt.reserve(first_operand.mVertcnt.size());
@@ -439,52 +417,46 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
     std::vector<unsigned int>::const_iterator begin = first_operand.mVertcnt.begin();
     std::vector<unsigned int>::const_iterator end = first_operand.mVertcnt.end();
     std::vector<unsigned int>::const_iterator iit;
-    for( iit = begin; iit != end; vidx += *iit++ )
-    {
+    for (iit = begin; iit != end; vidx += *iit++) {
         // Our new approach: we cut the poly along the plane, then we intersect the part on the black side of the plane
         // against the bounding polygon. All the white parts, and the black part outside the boundary polygon, are kept.
         std::vector<IfcVector3> whiteside, blackside;
 
         {
-            const IfcVector3* srcVertices = &in[vidx];
+            const IfcVector3 *srcVertices = &in[vidx];
             const size_t srcVtxCount = *iit;
-            if( srcVtxCount == 0 )
+            if (srcVtxCount == 0)
                 continue;
 
             IfcVector3 polyNormal = TempMesh::ComputePolygonNormal(srcVertices, srcVtxCount, true);
 
             // if the poly is parallel to the plane, put it completely on the black or white side
-            if( std::abs(polyNormal * n) > 0.9999 )
-            {
+            if (std::abs(polyNormal * n) > 0.9999) {
                 bool isOnWhiteSide = (srcVertices[0] - p) * n > -1e-6;
-                std::vector<IfcVector3>& targetSide = isOnWhiteSide ? whiteside : blackside;
+                std::vector<IfcVector3> &targetSide = isOnWhiteSide ? whiteside : blackside;
                 targetSide.insert(targetSide.end(), srcVertices, srcVertices + srcVtxCount);
-            }
-            else
-            {
+            } else {
                 // otherwise start building one polygon for each side. Whenever the current line segment intersects the plane
                 // we put a point there as an end of the current segment. Then we switch to the other side, put a point there, too,
                 // as a beginning of the current segment, and simply continue accumulating vertices.
                 bool isCurrentlyOnWhiteSide = ((srcVertices[0]) - p) * n > -1e-6;
-                for( size_t a = 0; a < srcVtxCount; ++a )
-                {
+                for (size_t a = 0; a < srcVtxCount; ++a) {
                     IfcVector3 e0 = srcVertices[a];
                     IfcVector3 e1 = srcVertices[(a + 1) % srcVtxCount];
                     IfcVector3 ei;
 
                     // put starting point to the current mesh
-                    std::vector<IfcVector3>& trgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
+                    std::vector<IfcVector3> &trgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
                     trgt.push_back(srcVertices[a]);
 
                     // if there's an intersection, put an end vertex there, switch to the other side's mesh,
                     // and add a starting vertex there, too
                     bool isPlaneHit = IntersectSegmentPlane(p, n, e0, e1, isCurrentlyOnWhiteSide, ei);
-                    if( isPlaneHit )
-                    {
-                        if( trgt.empty() || (trgt.back() - ei).SquareLength() > 1e-12 )
+                    if (isPlaneHit) {
+                        if (trgt.empty() || (trgt.back() - ei).SquareLength() > 1e-12)
                             trgt.push_back(ei);
                         isCurrentlyOnWhiteSide = !isCurrentlyOnWhiteSide;
-                        std::vector<IfcVector3>& newtrgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
+                        std::vector<IfcVector3> &newtrgt = isCurrentlyOnWhiteSide ? whiteside : blackside;
                         newtrgt.push_back(ei);
                     }
                 }
@@ -504,33 +476,27 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
         // an intersection, then we switch back to the poly and run on on this one again, and so on until we got a closed
         // loop. Then we continue with the path we left to catch potential additional polys on the other side of the
         // boundary as described in a)
-        if( !blackside.empty() )
-        {
+        if (!blackside.empty()) {
             // poly edge index, intersection point, edge index in boundary poly
-            std::vector<std::tuple<size_t, IfcVector3, size_t> > intersections;
+            std::vector<std::tuple<size_t, IfcVector3, size_t>> intersections;
             bool startedInside = PointInPoly(proj * blackside.front(), profile->mVerts);
             bool isCurrentlyInside = startedInside;
 
-            std::vector<std::pair<size_t, IfcVector3> > intersected_boundary;
+            std::vector<std::pair<size_t, IfcVector3>> intersected_boundary;
 
-            for( size_t a = 0; a < blackside.size(); ++a )
-            {
+            for (size_t a = 0; a < blackside.size(); ++a) {
                 const IfcVector3 e0 = proj * blackside[a];
                 const IfcVector3 e1 = proj * blackside[(a + 1) % blackside.size()];
 
                 intersected_boundary.clear();
                 IntersectsBoundaryProfile(e0, e1, profile->mVerts, isCurrentlyInside, intersected_boundary);
                 // sort the hits by distance from e0 to get the correct in/out/in sequence. Manually :-( I miss you, C++11.
-                if( intersected_boundary.size() > 1 )
-                {
+                if (intersected_boundary.size() > 1) {
                     bool keepSorting = true;
-                    while( keepSorting )
-                    {
+                    while (keepSorting) {
                         keepSorting = false;
-                        for( size_t b = 0; b < intersected_boundary.size() - 1; ++b )
-                        {
-                            if( (intersected_boundary[b + 1].second - e0).SquareLength() < (intersected_boundary[b].second - e0).SquareLength() )
-                            {
+                        for (size_t b = 0; b < intersected_boundary.size() - 1; ++b) {
+                            if ((intersected_boundary[b + 1].second - e0).SquareLength() < (intersected_boundary[b].second - e0).SquareLength()) {
                                 keepSorting = true;
                                 std::swap(intersected_boundary[b + 1], intersected_boundary[b]);
                             }
@@ -538,60 +504,52 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                     }
                 }
                 // now add them to the list of intersections
-                for( size_t b = 0; b < intersected_boundary.size(); ++b )
+                for (size_t b = 0; b < intersected_boundary.size(); ++b)
                     intersections.push_back(std::make_tuple(a, proj_inv * intersected_boundary[b].second, intersected_boundary[b].first));
 
                 // and calculate our new inside/outside state
-                if( intersected_boundary.size() & 1 )
+                if (intersected_boundary.size() & 1)
                     isCurrentlyInside = !isCurrentlyInside;
             }
 
             // we got a list of in-out-combinations of intersections. That should be an even number of intersections, or
             // we're fucked.
-            if( (intersections.size() & 1) != 0 )
-            {
+            if ((intersections.size() & 1) != 0) {
                 IFCImporter::LogWarn("Odd number of intersections, can't work with that. Omitting half space boundary check.");
                 continue;
             }
 
-            if( intersections.size() > 1 )
-            {
+            if (intersections.size() > 1) {
                 // If we started outside, the first intersection is a out->in intersection. Cycle them so that it
                 // starts with an intersection leaving the boundary
-                if( !startedInside )
-                for( size_t b = 0; b < intersections.size() - 1; ++b )
-                    std::swap(intersections[b], intersections[(b + intersections.size() - 1) % intersections.size()]);
+                if (!startedInside)
+                    for (size_t b = 0; b < intersections.size() - 1; ++b)
+                        std::swap(intersections[b], intersections[(b + intersections.size() - 1) % intersections.size()]);
 
                 // Filter pairs of out->in->out that lie too close to each other.
-                for( size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/ )
-                {
-                    if( (std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10 )
+                for (size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/) {
+                    if ((std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10)
                         intersections.erase(intersections.begin() + a, intersections.begin() + a + 2);
                     else
                         a++;
                 }
-                if( intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10 )
-                {
-                    intersections.pop_back(); intersections.erase(intersections.begin());
+                if (intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10) {
+                    intersections.pop_back();
+                    intersections.erase(intersections.begin());
                 }
             }
 
-
             // no intersections at all: either completely inside the boundary, so everything gets discarded, or completely outside.
             // in the latter case we're implementional lost. I'm simply going to ignore this, so a large poly will not get any
             // holes if the boundary is smaller and does not touch it anywhere.
-            if( intersections.empty() )
-            {
+            if (intersections.empty()) {
                 // starting point was outside -> everything is outside the boundary -> nothing is clipped -> add black side
                 // to result mesh unchanged
-                if( !startedInside )
-                {
+                if (!startedInside) {
                     outvertcnt.push_back(static_cast<unsigned int>(blackside.size()));
                     outvert.insert(outvert.end(), blackside.begin(), blackside.end());
                     continue;
-                }
-                else
-                {
+                } else {
                     // starting point was inside the boundary -> everything is inside the boundary -> nothing is spared from the
                     // clipping -> nothing left to add to the result mesh
                     continue;
@@ -608,13 +566,11 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
             // From there we walk along the boundary until we hit another intersection leaving the boundary,
             // walk along the poly to the next IS and so on until we're back at the starting point.
             // We remove every intersection we "used up", so any remaining intersection is the start of a new loop.
-            while( !intersections.empty() )
-            {
+            while (!intersections.empty()) {
                 std::vector<IfcVector3> resultpoly;
                 size_t currentIntersecIdx = 0;
 
-                while( true )
-                {
+                while (true) {
                     ai_assert(intersections.size() > currentIntersecIdx + 1);
                     std::tuple<size_t, IfcVector3, size_t> currintsec = intersections[currentIntersecIdx + 0];
                     std::tuple<size_t, IfcVector3, size_t> nextintsec = intersections[currentIntersecIdx + 1];
@@ -623,9 +579,8 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                     // we start with an in->out intersection
                     resultpoly.push_back(std::get<1>(currintsec));
                     // climb along the polygon to the next intersection, which should be an out->in
-                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0)
-                        + std::get<0>(nextintsec) - std::get<0>(currintsec);
-                    for( size_t a = 1; a <= numPolyPoints; ++a )
+                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0) + std::get<0>(nextintsec) - std::get<0>(currintsec);
+                    for (size_t a = 1; a <= numPolyPoints; ++a)
                         resultpoly.push_back(blackside[(std::get<0>(currintsec) + a) % blackside.size()]);
                     // put the out->in intersection
                     resultpoly.push_back(std::get<1>(nextintsec));
@@ -634,8 +589,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                     IfcVector3 startingPoint = proj * std::get<1>(nextintsec);
                     size_t currentBoundaryEdgeIdx = (std::get<2>(nextintsec) + (marchBackwardsOnBoundary ? 1 : 0)) % profile->mVerts.size();
                     size_t nextIntsecIdx = SIZE_MAX;
-                    while( nextIntsecIdx == SIZE_MAX )
-                    {
+                    while (nextIntsecIdx == SIZE_MAX) {
                         IfcFloat t = 1e10;
 
                         size_t nextBoundaryEdgeIdx = marchBackwardsOnBoundary ? (currentBoundaryEdgeIdx + profile->mVerts.size() - 1) : currentBoundaryEdgeIdx + 1;
@@ -644,10 +598,9 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                         IfcVector3 currBoundaryPoint = profile->mVerts[currentBoundaryEdgeIdx];
                         IfcVector3 nextBoundaryPoint = profile->mVerts[nextBoundaryEdgeIdx];
                         // project the two onto the polygon
-                        if( std::abs(polyNormal.z) > 1e-5 )
-                        {
-                            currBoundaryPoint.z = startingPoint.z + (currBoundaryPoint.x - startingPoint.x) * polyNormal.x/polyNormal.z + (currBoundaryPoint.y - startingPoint.y) * polyNormal.y/polyNormal.z;
-                            nextBoundaryPoint.z = startingPoint.z + (nextBoundaryPoint.x - startingPoint.x) * polyNormal.x/polyNormal.z + (nextBoundaryPoint.y - startingPoint.y) * polyNormal.y/polyNormal.z;
+                        if (std::abs(polyNormal.z) > 1e-5) {
+                            currBoundaryPoint.z = startingPoint.z + (currBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (currBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
+                            nextBoundaryPoint.z = startingPoint.z + (nextBoundaryPoint.x - startingPoint.x) * polyNormal.x / polyNormal.z + (nextBoundaryPoint.y - startingPoint.y) * polyNormal.y / polyNormal.z;
                         }
 
                         // build a direction that goes along the boundary border but lies in the poly plane
@@ -655,52 +608,45 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
                         IfcVector3 dirAtPolyPlane = (boundaryPlaneNormal ^ polyNormal).Normalize() * (marchBackwardsOnBoundary ? -1.0 : 1.0);
                         // if we can project the direction to the plane, we can calculate a maximum marching distance along that dir
                         // until we finish that boundary segment and continue on the next
-                        if( std::abs(polyNormal.z) > 1e-5 )
-                        {
+                        if (std::abs(polyNormal.z) > 1e-5) {
                             t = std::min(t, (nextBoundaryPoint - startingPoint).Length());
                         }
 
                         // check if the direction hits the loop start - if yes, we got a poly to output
                         IfcVector3 dirToThatPoint = proj * resultpoly.front() - startingPoint;
                         IfcFloat tpt = dirToThatPoint * dirAtPolyPlane;
-                        if( tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10 )
-                        {
+                        if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
                             nextIntsecIdx = intersections.size(); // dirty hack to end marching along the boundary and signal the end of the loop
                             t = tpt;
                         }
 
                         // also check if the direction hits any in->out intersections earlier. If we hit one, we can switch back
                         // to marching along the poly border from that intersection point
-                        for( size_t a = 0; a < intersections.size(); a += 2 )
-                        {
+                        for (size_t a = 0; a < intersections.size(); a += 2) {
                             dirToThatPoint = proj * std::get<1>(intersections[a]) - startingPoint;
                             tpt = dirToThatPoint * dirAtPolyPlane;
-                            if( tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10 )
-                            {
+                            if (tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10) {
                                 nextIntsecIdx = a; // switch back to poly and march on from this in->out intersection
                                 t = tpt;
                             }
                         }
 
                         // if we keep marching on the boundary, put the segment end point to the result poly and well... keep marching
-                        if( nextIntsecIdx == SIZE_MAX )
-                        {
+                        if (nextIntsecIdx == SIZE_MAX) {
                             resultpoly.push_back(proj_inv * nextBoundaryPoint);
                             currentBoundaryEdgeIdx = nextBoundaryEdgeIdx;
                             startingPoint = nextBoundaryPoint;
                         }
 
                         // quick endless loop check
-                        if( resultpoly.size() > blackside.size() + profile->mVerts.size() )
-                        {
+                        if (resultpoly.size() > blackside.size() + profile->mVerts.size()) {
                             IFCImporter::LogError("Encountered endless loop while clipping polygon against poly-bounded half space.");
                             break;
                         }
                     }
 
                     // we're back on the poly - if this is the intersection we started from, we got a closed loop.
-                    if( nextIntsecIdx >= intersections.size() )
-                    {
+                    if (nextIntsecIdx >= intersections.size()) {
                         break;
                     }
 
@@ -716,10 +662,9 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const Schema_2x3::IfcPoly
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid* as, TempMesh& result,
-                                               const TempMesh& first_operand,
-                                               ConversionData& conv)
-{
+void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedAreaSolid *as, TempMesh &result,
+        const TempMesh &first_operand,
+        ConversionData &conv) {
     ai_assert(as != NULL);
 
     // This case is handled by reduction to an instance of the quadrify() algorithm.
@@ -728,16 +673,16 @@ void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedArea
     // buildings.
 
     std::shared_ptr<TempMesh> meshtmp = std::shared_ptr<TempMesh>(new TempMesh());
-    ProcessExtrudedAreaSolid(*as,*meshtmp,conv,false);
+    ProcessExtrudedAreaSolid(*as, *meshtmp, conv, false);
 
-    std::vector<TempOpening> openings(1, TempOpening(as,IfcVector3(0,0,0),meshtmp,std::shared_ptr<TempMesh>()));
+    std::vector<TempOpening> openings(1, TempOpening(as, IfcVector3(0, 0, 0), meshtmp, std::shared_ptr<TempMesh>()));
 
     result = first_operand;
 
     TempMesh temp;
 
     std::vector<IfcVector3>::const_iterator vit = first_operand.mVerts.begin();
-    for(unsigned int pcount : first_operand.mVertcnt) {
+    for (unsigned int pcount : first_operand.mVertcnt) {
         temp.Clear();
 
         temp.mVerts.insert(temp.mVerts.end(), vit, vit + pcount);
@@ -749,13 +694,13 @@ void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedArea
 
         // ComputePolygonNormal returns the Newell normal, so the
         // length of the normal is the area of the polygon.
-        const IfcVector3& normal = temp.ComputeLastPolygonNormal(false);
+        const IfcVector3 &normal = temp.ComputeLastPolygonNormal(false);
         if (normal.SquareLength() < static_cast<IfcFloat>(1e-5)) {
             IFCImporter::LogWarn("skipping degenerate polygon (ProcessBooleanExtrudedAreaSolidDifference)");
             continue;
         }
 
-        GenerateOpenings(openings, std::vector<IfcVector3>(1,IfcVector3(1,0,0)), temp, false, true);
+        GenerateOpenings(openings, std::vector<IfcVector3>(1, IfcVector3(1, 0, 0)), temp, false, true);
         result.Append(temp);
 
         vit += pcount;
@@ -765,12 +710,11 @@ void ProcessBooleanExtrudedAreaSolidDifference(const Schema_2x3::IfcExtrudedArea
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& result, ConversionData& conv)
-{
+void ProcessBoolean(const Schema_2x3::IfcBooleanResult &boolean, TempMesh &result, ConversionData &conv) {
     // supported CSG operations:
     //   DIFFERENCE
-    if(const Schema_2x3::IfcBooleanResult* const clip = boolean.ToPtr<Schema_2x3::IfcBooleanResult>()) {
-        if(clip->Operator != "DIFFERENCE") {
+    if (const Schema_2x3::IfcBooleanResult *const clip = boolean.ToPtr<Schema_2x3::IfcBooleanResult>()) {
+        if (clip->Operator != "DIFFERENCE") {
             IFCImporter::LogWarn("encountered unsupported boolean operator: " + (std::string)clip->Operator);
             return;
         }
@@ -783,47 +727,40 @@ void ProcessBoolean(const Schema_2x3::IfcBooleanResult& boolean, TempMesh& resul
         //  IfcHalfSpaceSolid -- easy, clip against plane
         //  IfcExtrudedAreaSolid -- reduce to an instance of the quadrify() algorithm
 
-
-        const Schema_2x3::IfcHalfSpaceSolid* const hs = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcHalfSpaceSolid>(conv.db);
-        const Schema_2x3::IfcExtrudedAreaSolid* const as = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcExtrudedAreaSolid>(conv.db);
-        if(!hs && !as) {
+        const Schema_2x3::IfcHalfSpaceSolid *const hs = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcHalfSpaceSolid>(conv.db);
+        const Schema_2x3::IfcExtrudedAreaSolid *const as = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcExtrudedAreaSolid>(conv.db);
+        if (!hs && !as) {
             IFCImporter::LogError("expected IfcHalfSpaceSolid or IfcExtrudedAreaSolid as second clipping operand");
             return;
         }
 
         TempMesh first_operand;
-        if(const Schema_2x3::IfcBooleanResult* const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
-            ProcessBoolean(*op0,first_operand,conv);
-        }
-        else if (const Schema_2x3::IfcSweptAreaSolid* const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
-            ProcessSweptAreaSolid(*swept,first_operand,conv);
-        }
-        else {
+        if (const Schema_2x3::IfcBooleanResult *const op0 = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcBooleanResult>(conv.db)) {
+            ProcessBoolean(*op0, first_operand, conv);
+        } else if (const Schema_2x3::IfcSweptAreaSolid *const swept = clip->FirstOperand->ResolveSelectPtr<Schema_2x3::IfcSweptAreaSolid>(conv.db)) {
+            ProcessSweptAreaSolid(*swept, first_operand, conv);
+        } else {
             IFCImporter::LogError("expected IfcSweptAreaSolid or IfcBooleanResult as first clipping operand");
             return;
         }
 
-        if(hs) {
+        if (hs) {
 
-            const Schema_2x3::IfcPolygonalBoundedHalfSpace* const hs_bounded = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcPolygonalBoundedHalfSpace>(conv.db);
+            const Schema_2x3::IfcPolygonalBoundedHalfSpace *const hs_bounded = clip->SecondOperand->ResolveSelectPtr<Schema_2x3::IfcPolygonalBoundedHalfSpace>(conv.db);
             if (hs_bounded) {
                 ProcessPolygonalBoundedBooleanHalfSpaceDifference(hs_bounded, result, first_operand, conv);
-            }
-            else {
+            } else {
                 ProcessBooleanHalfSpaceDifference(hs, result, first_operand, conv);
             }
-        }
-        else {
+        } else {
             ProcessBooleanExtrudedAreaSolidDifference(as, result, first_operand, conv);
         }
-    }
-    else {
+    } else {
         IFCImporter::LogWarn("skipping unknown IfcBooleanResult entity, type is " + boolean.GetClassName());
     }
 }
 
-} // ! IFC
-} // ! Assimp
+} // namespace IFC
+} // namespace Assimp
 
 #endif
-
diff --git a/code/Importer/IFC/IFCCurve.cpp b/code/AssetLib/IFC/IFCCurve.cpp
similarity index 100%
rename from code/Importer/IFC/IFCCurve.cpp
rename to code/AssetLib/IFC/IFCCurve.cpp
diff --git a/code/Importer/IFC/IFCGeometry.cpp b/code/AssetLib/IFC/IFCGeometry.cpp
similarity index 100%
rename from code/Importer/IFC/IFCGeometry.cpp
rename to code/AssetLib/IFC/IFCGeometry.cpp
diff --git a/code/Importer/IFC/IFCLoader.cpp b/code/AssetLib/IFC/IFCLoader.cpp
similarity index 100%
rename from code/Importer/IFC/IFCLoader.cpp
rename to code/AssetLib/IFC/IFCLoader.cpp
diff --git a/code/Importer/IFC/IFCLoader.h b/code/AssetLib/IFC/IFCLoader.h
similarity index 100%
rename from code/Importer/IFC/IFCLoader.h
rename to code/AssetLib/IFC/IFCLoader.h
diff --git a/code/Importer/IFC/IFCMaterial.cpp b/code/AssetLib/IFC/IFCMaterial.cpp
similarity index 100%
rename from code/Importer/IFC/IFCMaterial.cpp
rename to code/AssetLib/IFC/IFCMaterial.cpp
diff --git a/code/Importer/IFC/IFCOpenings.cpp b/code/AssetLib/IFC/IFCOpenings.cpp
similarity index 100%
rename from code/Importer/IFC/IFCOpenings.cpp
rename to code/AssetLib/IFC/IFCOpenings.cpp
diff --git a/code/Importer/IFC/IFCProfile.cpp b/code/AssetLib/IFC/IFCProfile.cpp
similarity index 100%
rename from code/Importer/IFC/IFCProfile.cpp
rename to code/AssetLib/IFC/IFCProfile.cpp
diff --git a/code/Importer/IFC/IFCReaderGen1_2x3.cpp b/code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
similarity index 100%
rename from code/Importer/IFC/IFCReaderGen1_2x3.cpp
rename to code/AssetLib/IFC/IFCReaderGen1_2x3.cpp
diff --git a/code/Importer/IFC/IFCReaderGen2_2x3.cpp b/code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
similarity index 100%
rename from code/Importer/IFC/IFCReaderGen2_2x3.cpp
rename to code/AssetLib/IFC/IFCReaderGen2_2x3.cpp
diff --git a/code/Importer/IFC/IFCReaderGen_2x3.h b/code/AssetLib/IFC/IFCReaderGen_2x3.h
similarity index 99%
rename from code/Importer/IFC/IFCReaderGen_2x3.h
rename to code/AssetLib/IFC/IFCReaderGen_2x3.h
index c8166b983..8ae623dd8 100644
--- a/code/Importer/IFC/IFCReaderGen_2x3.h
+++ b/code/AssetLib/IFC/IFCReaderGen_2x3.h
@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IFC_READER_GEN_H
 #define INCLUDED_IFC_READER_GEN_H
 
-#include "code/Step/STEPFile.h"
+#include "AssetLib/Step/STEPFile.h"
 
 #ifdef _WIN32
 #    pragma warning( disable : 4512 )
diff --git a/code/Importer/IFC/IFCReaderGen_4.cpp b/code/AssetLib/IFC/IFCReaderGen_4.cpp
similarity index 100%
rename from code/Importer/IFC/IFCReaderGen_4.cpp
rename to code/AssetLib/IFC/IFCReaderGen_4.cpp
diff --git a/code/Importer/IFC/IFCReaderGen_4.h b/code/AssetLib/IFC/IFCReaderGen_4.h
similarity index 100%
rename from code/Importer/IFC/IFCReaderGen_4.h
rename to code/AssetLib/IFC/IFCReaderGen_4.h
diff --git a/code/Importer/IFC/IFCUtil.cpp b/code/AssetLib/IFC/IFCUtil.cpp
similarity index 99%
rename from code/Importer/IFC/IFCUtil.cpp
rename to code/AssetLib/IFC/IFCUtil.cpp
index 5e1612bf1..2620160df 100644
--- a/code/Importer/IFC/IFCUtil.cpp
+++ b/code/AssetLib/IFC/IFCUtil.cpp
@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
 
-#include "Importer/IFC/IFCUtil.h"
+#include "AssetLib/IFC/IFCUtil.h"
 #include "Common/PolyTools.h"
 #include "PostProcessing/ProcessHelper.h"
 #include <assimp/Defines.h>
diff --git a/code/Importer/IFC/IFCUtil.h b/code/AssetLib/IFC/IFCUtil.h
similarity index 99%
rename from code/Importer/IFC/IFCUtil.h
rename to code/AssetLib/IFC/IFCUtil.h
index cf8c94293..b9aad4440 100644
--- a/code/Importer/IFC/IFCUtil.h
+++ b/code/AssetLib/IFC/IFCUtil.h
@@ -47,9 +47,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_IFCUTIL_H
 #define INCLUDED_IFCUTIL_H
 
-#include "IFCReaderGen_2x3.h"
-#include "IFCLoader.h"
-#include "code/Step/STEPFile.h"
+#include "AssetLib/IFC/IFCReaderGen_2x3.h"
+#include "AssetLib/IFC/IFCLoader.h"
+#include "AssetLib/Step/STEPFile.h"
+
 #include <assimp/mesh.h>
 #include <assimp/material.h>
 
diff --git a/code/Irr/IRRLoader.cpp b/code/AssetLib/Irr/IRRLoader.cpp
similarity index 99%
rename from code/Irr/IRRLoader.cpp
rename to code/AssetLib/Irr/IRRLoader.cpp
index f38ec367c..f7e71b547 100644
--- a/code/Irr/IRRLoader.cpp
+++ b/code/AssetLib/Irr/IRRLoader.cpp
@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
 
-#include "Irr/IRRLoader.h"
+#include "AssetLib/Irr/IRRLoader.h"
 #include "Common/Importer.h"
 
 #include <assimp/ParsingUtils.h>
diff --git a/code/Irr/IRRLoader.h b/code/AssetLib/Irr/IRRLoader.h
similarity index 99%
rename from code/Irr/IRRLoader.h
rename to code/AssetLib/Irr/IRRLoader.h
index fc6f77031..21908c14a 100644
--- a/code/Irr/IRRLoader.h
+++ b/code/AssetLib/Irr/IRRLoader.h
@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_IRRLOADER_H_INCLUDED
 #define AI_IRRLOADER_H_INCLUDED
 
-#include "Irr/IRRShared.h"
+#include "AssetLib/Irr/IRRShared.h"
 #include "Common/Importer.h"
 
 #include <assimp/SceneCombiner.h>
diff --git a/code/Irr/IRRMeshLoader.cpp b/code/AssetLib/Irr/IRRMeshLoader.cpp
similarity index 100%
rename from code/Irr/IRRMeshLoader.cpp
rename to code/AssetLib/Irr/IRRMeshLoader.cpp
diff --git a/code/Irr/IRRMeshLoader.h b/code/AssetLib/Irr/IRRMeshLoader.h
similarity index 100%
rename from code/Irr/IRRMeshLoader.h
rename to code/AssetLib/Irr/IRRMeshLoader.h
diff --git a/code/Irr/IRRShared.cpp b/code/AssetLib/Irr/IRRShared.cpp
similarity index 100%
rename from code/Irr/IRRShared.cpp
rename to code/AssetLib/Irr/IRRShared.cpp
diff --git a/code/Irr/IRRShared.h b/code/AssetLib/Irr/IRRShared.h
similarity index 100%
rename from code/Irr/IRRShared.h
rename to code/AssetLib/Irr/IRRShared.h
diff --git a/code/LWO/LWOAnimation.cpp b/code/AssetLib/LWO/LWOAnimation.cpp
similarity index 56%
rename from code/LWO/LWOAnimation.cpp
rename to code/AssetLib/LWO/LWOAnimation.cpp
index c5913b7f1..228dea26d 100644
--- a/code/LWO/LWOAnimation.cpp
+++ b/code/AssetLib/LWO/LWOAnimation.cpp
@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -44,11 +43,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief LWOAnimationResolver utility class
  *
  *  It's a very generic implementation of LightWave's system of
- *  componentwise-animated stuff. The one and only fully free
+ *  component-wise-animated stuff. The one and only fully free
  *  implementation of LightWave envelopes of which I know.
 */
 
-
 #if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER) && (!defined ASSIMP_BUILD_NO_LWS_IMPORTER)
 
 #include <functional>
@@ -62,17 +60,20 @@ using namespace Assimp::LWO;
 
 // ------------------------------------------------------------------------------------------------
 // Construct an animation resolver from a given list of envelopes
-AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
-    : envelopes   (_envelopes)
-    , sample_rate (0.)
-    , envl_x(), envl_y(), envl_z()
-    , end_x(), end_y(), end_z()
-    , flags()
-    , sample_delta()
-{
-    trans_x = trans_y = trans_z = NULL;
-    rotat_x = rotat_y = rotat_z = NULL;
-    scale_x = scale_y = scale_z = NULL;
+AnimResolver::AnimResolver(std::list<Envelope> &_envelopes, double tick) :
+        envelopes(_envelopes),
+        sample_rate(0.),
+        envl_x(),
+        envl_y(),
+        envl_z(),
+        end_x(),
+        end_y(),
+        end_z(),
+        flags(),
+        sample_delta() {
+    trans_x = trans_y = trans_z = nullptr;
+    rotat_x = rotat_y = rotat_z = nullptr;
+    scale_x = scale_y = scale_z = nullptr;
 
     first = last = 150392.;
 
@@ -80,36 +81,45 @@ AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
     for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) {
 
         (*it).old_first = 0;
-        (*it).old_last  = (*it).keys.size()-1;
+        (*it).old_last = (*it).keys.size() - 1;
 
         if ((*it).keys.empty()) continue;
         switch ((*it).type) {
 
-            // translation
-            case LWO::EnvelopeType_Position_X:
-                trans_x = &*it;break;
-            case LWO::EnvelopeType_Position_Y:
-                trans_y = &*it;break;
-            case LWO::EnvelopeType_Position_Z:
-                trans_z = &*it;break;
+        // translation
+        case LWO::EnvelopeType_Position_X:
+            trans_x = &*it;
+            break;
+        case LWO::EnvelopeType_Position_Y:
+            trans_y = &*it;
+            break;
+        case LWO::EnvelopeType_Position_Z:
+            trans_z = &*it;
+            break;
 
-                // rotation
-            case LWO::EnvelopeType_Rotation_Heading:
-                rotat_x = &*it;break;
-            case LWO::EnvelopeType_Rotation_Pitch:
-                rotat_y = &*it;break;
-            case LWO::EnvelopeType_Rotation_Bank:
-                rotat_z = &*it;break;
+            // rotation
+        case LWO::EnvelopeType_Rotation_Heading:
+            rotat_x = &*it;
+            break;
+        case LWO::EnvelopeType_Rotation_Pitch:
+            rotat_y = &*it;
+            break;
+        case LWO::EnvelopeType_Rotation_Bank:
+            rotat_z = &*it;
+            break;
 
-                // scaling
-            case LWO::EnvelopeType_Scaling_X:
-                scale_x = &*it;break;
-            case LWO::EnvelopeType_Scaling_Y:
-                scale_y = &*it;break;
-            case LWO::EnvelopeType_Scaling_Z:
-                scale_z = &*it;break;
-            default:
-                continue;
+            // scaling
+        case LWO::EnvelopeType_Scaling_X:
+            scale_x = &*it;
+            break;
+        case LWO::EnvelopeType_Scaling_Y:
+            scale_y = &*it;
+            break;
+        case LWO::EnvelopeType_Scaling_Z:
+            scale_z = &*it;
+            break;
+        default:
+            continue;
         };
 
         // convert from seconds to ticks
@@ -117,8 +127,8 @@ AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
             (*d).time *= tick;
 
         // set default animation range (minimum and maximum time value for which we have a keyframe)
-        first = std::min(first, (*it).keys.front().time );
-        last  = std::max(last,  (*it).keys.back().time );
+        first = std::min(first, (*it).keys.front().time);
+        last = std::max(last, (*it).keys.back().time);
     }
 
     // deferred setup of animation range to increase performance.
@@ -128,28 +138,26 @@ AnimResolver::AnimResolver(std::list<Envelope>& _envelopes,double tick)
 
 // ------------------------------------------------------------------------------------------------
 // Reset all envelopes to their original contents
-void AnimResolver::ClearAnimRangeSetup()
-{
+void AnimResolver::ClearAnimRangeSetup() {
     for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) {
 
-        (*it).keys.erase((*it).keys.begin(),(*it).keys.begin()+(*it).old_first);
-        (*it).keys.erase((*it).keys.begin()+(*it).old_last+1,(*it).keys.end());
+        (*it).keys.erase((*it).keys.begin(), (*it).keys.begin() + (*it).old_first);
+        (*it).keys.erase((*it).keys.begin() + (*it).old_last + 1, (*it).keys.end());
     }
 }
 
 // ------------------------------------------------------------------------------------------------
-// Insert additional keys to match LWO's pre& post behaviours.
-void AnimResolver::UpdateAnimRangeSetup()
-{
+// Insert additional keys to match LWO's pre& post behaviors.
+void AnimResolver::UpdateAnimRangeSetup() {
     // XXX doesn't work yet (hangs if more than one envelope channels needs to be interpolated)
 
     for (std::list<LWO::Envelope>::iterator it = envelopes.begin(); it != envelopes.end(); ++it) {
         if ((*it).keys.empty()) continue;
 
         const double my_first = (*it).keys.front().time;
-        const double my_last  = (*it).keys.back().time;
+        const double my_last = (*it).keys.back().time;
 
-        const double delta = my_last-my_first;
+        const double delta = my_last - my_first;
         const size_t old_size = (*it).keys.size();
 
         const float value_delta = (*it).keys.back().value - (*it).keys.front().value;
@@ -157,89 +165,88 @@ void AnimResolver::UpdateAnimRangeSetup()
         // NOTE: We won't handle reset, linear and constant here.
         // See DoInterpolation() for their implementation.
 
-        // process pre behaviour
+        // process pre behavior
         switch ((*it).pre) {
-            case LWO::PrePostBehaviour_OffsetRepeat:
-            case LWO::PrePostBehaviour_Repeat:
-            case LWO::PrePostBehaviour_Oscillate:
-                {
-                const double start_time = delta - std::fmod(my_first-first,delta);
-                std::vector<LWO::Key>::iterator n = std::find_if((*it).keys.begin(),(*it).keys.end(),
-                    [start_time](double t) { return start_time > t; }),m;
+        case LWO::PrePostBehaviour_OffsetRepeat:
+        case LWO::PrePostBehaviour_Repeat:
+        case LWO::PrePostBehaviour_Oscillate: {
+            const double start_time = delta - std::fmod(my_first - first, delta);
+            std::vector<LWO::Key>::iterator n = std::find_if((*it).keys.begin(), (*it).keys.end(),
+                                                    [start_time](double t) { return start_time > t; }),
+                                            m;
 
-                size_t ofs = 0;
-                if (n != (*it).keys.end()) {
-                    // copy from here - don't use iterators, insert() would invalidate them
-                    ofs = (*it).keys.end()-n;
-                    (*it).keys.insert((*it).keys.begin(),ofs,LWO::Key());
+            size_t ofs = 0;
+            if (n != (*it).keys.end()) {
+                // copy from here - don't use iterators, insert() would invalidate them
+                ofs = (*it).keys.end() - n;
+                (*it).keys.insert((*it).keys.begin(), ofs, LWO::Key());
 
-                    std::copy((*it).keys.end()-ofs,(*it).keys.end(),(*it).keys.begin());
+                std::copy((*it).keys.end() - ofs, (*it).keys.end(), (*it).keys.begin());
+            }
+
+            // do full copies. again, no iterators
+            const unsigned int num = (unsigned int)((my_first - first) / delta);
+            (*it).keys.resize((*it).keys.size() + num * old_size);
+
+            n = (*it).keys.begin() + ofs;
+            bool reverse = false;
+            for (unsigned int i = 0; i < num; ++i) {
+                m = n + old_size * (i + 1);
+                std::copy(n, n + old_size, m);
+                const bool res = ((*it).pre == LWO::PrePostBehaviour_Oscillate);
+                reverse = !reverse;
+                if (res && reverse) {
+                    std::reverse(m, m + old_size - 1);
                 }
+            }
 
-                // do full copies. again, no iterators
-                const unsigned int num = (unsigned int)((my_first-first) / delta);
-                (*it).keys.resize((*it).keys.size() + num*old_size);
+            // update time values
+            n = (*it).keys.end() - (old_size + 1);
+            double cur_minus = delta;
+            unsigned int tt = 1;
+            for (const double tmp = delta * (num + 1); cur_minus <= tmp; cur_minus += delta, ++tt) {
+                m = (delta == tmp ? (*it).keys.begin() : n - (old_size + 1));
+                for (; m != n; --n) {
+                    (*n).time -= cur_minus;
 
-                n = (*it).keys.begin()+ofs;
-                bool reverse = false;
-                for (unsigned int i = 0; i < num; ++i) {
-                    m = n+old_size*(i+1);
-                    std::copy(n,n+old_size,m);
-                    const bool res = ((*it).pre == LWO::PrePostBehaviour_Oscillate);
-                    reverse = !reverse;
-                    if (res && reverse ) {
-                        std::reverse(m,m+old_size-1);
+                    // offset repeat? add delta offset to key value
+                    if ((*it).pre == LWO::PrePostBehaviour_OffsetRepeat) {
+                        (*n).value += tt * value_delta;
                     }
                 }
-
-                // update time values
-                n = (*it).keys.end() - (old_size+1);
-                double cur_minus = delta;
-                unsigned int tt = 1;
-                for (const double tmp =  delta*(num+1);cur_minus <= tmp;cur_minus += delta,++tt) {
-                    m = (delta == tmp ? (*it).keys.begin() :  n - (old_size+1));
-                    for (;m != n; --n) {
-                        (*n).time -= cur_minus;
-
-                        // offset repeat? add delta offset to key value
-                        if ((*it).pre == LWO::PrePostBehaviour_OffsetRepeat) {
-                            (*n).value += tt * value_delta;
-                        }
-                    }
-                }
-                break;
-                }
-            default:
-                // silence compiler warning
-                break;
+            }
+            break;
+        }
+        default:
+            // silence compiler warning
+            break;
         }
 
-        // process post behaviour
+        // process post behavior
         switch ((*it).post) {
 
-            case LWO::PrePostBehaviour_OffsetRepeat:
-            case LWO::PrePostBehaviour_Repeat:
-            case LWO::PrePostBehaviour_Oscillate:
+        case LWO::PrePostBehaviour_OffsetRepeat:
+        case LWO::PrePostBehaviour_Repeat:
+        case LWO::PrePostBehaviour_Oscillate:
 
-                break;
+            break;
 
-            default:
-                // silence compiler warning
-                break;
+        default:
+            // silence compiler warning
+            break;
         }
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Extract bind pose matrix
-void AnimResolver::ExtractBindPose(aiMatrix4x4& out)
-{
+void AnimResolver::ExtractBindPose(aiMatrix4x4 &out) {
     // If we have no envelopes, return identity
     if (envelopes.empty()) {
         out = aiMatrix4x4();
         return;
     }
-    aiVector3D angles, scaling(1.f,1.f,1.f), translation;
+    aiVector3D angles, scaling(1.f, 1.f, 1.f), translation;
 
     if (trans_x) translation.x = trans_x->keys[0].value;
     if (trans_y) translation.y = trans_y->keys[0].value;
@@ -254,20 +261,19 @@ void AnimResolver::ExtractBindPose(aiMatrix4x4& out)
     if (scale_z) scaling.z = scale_z->keys[0].value;
 
     // build the final matrix
-    aiMatrix4x4 s,rx,ry,rz,t;
+    aiMatrix4x4 s, rx, ry, rz, t;
     aiMatrix4x4::RotationZ(angles.z, rz);
     aiMatrix4x4::RotationX(angles.y, rx);
     aiMatrix4x4::RotationY(angles.x, ry);
-    aiMatrix4x4::Translation(translation,t);
-    aiMatrix4x4::Scaling(scaling,s);
-    out = t*ry*rx*rz*s;
+    aiMatrix4x4::Translation(translation, t);
+    aiMatrix4x4::Scaling(scaling, s);
+    out = t * ry * rx * rz * s;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Do a single interpolation on a channel
 void AnimResolver::DoInterpolation(std::vector<LWO::Key>::const_iterator cur,
-    LWO::Envelope* envl,double time, float& fill)
-{
+        LWO::Envelope *envl, double time, float &fill) {
     if (envl->keys.size() == 1) {
         fill = envl->keys[0].value;
         return;
@@ -278,64 +284,61 @@ void AnimResolver::DoInterpolation(std::vector<LWO::Key>::const_iterator cur,
 
         // ok ... this depends on pre behaviour now
         // we don't need to handle repeat&offset repeat&oszillate here, see UpdateAnimRangeSetup()
-        switch (envl->pre)
-        {
+        switch (envl->pre) {
         case LWO::PrePostBehaviour_Linear:
-            DoInterpolation2(cur,cur+1,time,fill);
+            DoInterpolation2(cur, cur + 1, time, fill);
             return;
 
         case LWO::PrePostBehaviour_Reset:
             fill = 0.f;
             return;
 
-        default : //case LWO::PrePostBehaviour_Constant:
+        default: //case LWO::PrePostBehaviour_Constant:
             fill = (*cur).value;
             return;
         }
     }
     // check whether we're at the end of the animation track
-    else if (cur == envl->keys.end()-1 && time > envl->keys.rbegin()->time) {
+    else if (cur == envl->keys.end() - 1 && time > envl->keys.rbegin()->time) {
         // ok ... this depends on post behaviour now
-        switch (envl->post)
-        {
+        switch (envl->post) {
         case LWO::PrePostBehaviour_Linear:
-            DoInterpolation2(cur,cur-1,time,fill);
+            DoInterpolation2(cur, cur - 1, time, fill);
             return;
 
         case LWO::PrePostBehaviour_Reset:
             fill = 0.f;
             return;
 
-        default : //case LWO::PrePostBehaviour_Constant:
+        default: //case LWO::PrePostBehaviour_Constant:
             fill = (*cur).value;
             return;
         }
     }
 
     // Otherwise do a simple interpolation
-    DoInterpolation2(cur-1,cur,time,fill);
+    DoInterpolation2(cur - 1, cur, time, fill);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Almost the same, except we won't handle pre/post conditions here
 void AnimResolver::DoInterpolation2(std::vector<LWO::Key>::const_iterator beg,
-    std::vector<LWO::Key>::const_iterator end,double time, float& fill)
-{
+        std::vector<LWO::Key>::const_iterator end, double time, float &fill) {
     switch ((*end).inter) {
 
-        case LWO::IT_STEP:
-            // no interpolation at all - take the value of the last key
-            fill = (*beg).value;
-            return;
-        default:
+    case LWO::IT_STEP:
+        // no interpolation at all - take the value of the last key
+        fill = (*beg).value;
+        return;
+    default:
 
-            // silence compiler warning
-            break;
+        // silence compiler warning
+        break;
     }
     // linear interpolation - default
     double duration = (*end).time - (*beg).time;
     if (duration > 0.0) {
-        fill = (*beg).value + ((*end).value - (*beg).value)*(float)(((time - (*beg).time) / duration));
+        fill = (*beg).value + ((*end).value - (*beg).value) * (float)(((time - (*beg).time) / duration));
     } else {
         fill = (*beg).value;
     }
@@ -343,22 +346,20 @@ void AnimResolver::DoInterpolation2(std::vector<LWO::Key>::const_iterator beg,
 
 // ------------------------------------------------------------------------------------------------
 // Subsample animation track by given key values
-void AnimResolver::SubsampleAnimTrack(std::vector<aiVectorKey>& /*out*/,
-    double /*time*/ ,double /*sample_delta*/ )
-{
+void AnimResolver::SubsampleAnimTrack(std::vector<aiVectorKey> & /*out*/,
+        double /*time*/, double /*sample_delta*/) {
     //ai_assert(out.empty() && sample_delta);
 
     //const double time_start = out.back().mTime;
-//  for ()
+    //  for ()
 }
 
 // ------------------------------------------------------------------------------------------------
 // Track interpolation
-void AnimResolver::InterpolateTrack(std::vector<aiVectorKey>& out,aiVectorKey& fill,double time)
-{
+void AnimResolver::InterpolateTrack(std::vector<aiVectorKey> &out, aiVectorKey &fill, double time) {
     // subsample animation track?
     if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) {
-        SubsampleAnimTrack(out,time, sample_delta);
+        SubsampleAnimTrack(out, time, sample_delta);
     }
 
     fill.mTime = time;
@@ -367,56 +368,58 @@ void AnimResolver::InterpolateTrack(std::vector<aiVectorKey>& out,aiVectorKey& f
     if ((*cur_x).time == time) {
         fill.mValue.x = (*cur_x).value;
 
-        if (cur_x != envl_x->keys.end()-1) /* increment x */
+        if (cur_x != envl_x->keys.end() - 1) /* increment x */
             ++cur_x;
-        else end_x = true;
-    }
-    else DoInterpolation(cur_x,envl_x,time,(float&)fill.mValue.x);
+        else
+            end_x = true;
+    } else
+        DoInterpolation(cur_x, envl_x, time, (float &)fill.mValue.x);
 
     // get y
     if ((*cur_y).time == time) {
         fill.mValue.y = (*cur_y).value;
 
-        if (cur_y != envl_y->keys.end()-1) /* increment y */
+        if (cur_y != envl_y->keys.end() - 1) /* increment y */
             ++cur_y;
-        else end_y = true;
-    }
-    else DoInterpolation(cur_y,envl_y,time,(float&)fill.mValue.y);
+        else
+            end_y = true;
+    } else
+        DoInterpolation(cur_y, envl_y, time, (float &)fill.mValue.y);
 
     // get z
     if ((*cur_z).time == time) {
         fill.mValue.z = (*cur_z).value;
 
-        if (cur_z != envl_z->keys.end()-1) /* increment z */
+        if (cur_z != envl_z->keys.end() - 1) /* increment z */
             ++cur_z;
-        else end_x = true;
-    }
-    else DoInterpolation(cur_z,envl_z,time,(float&)fill.mValue.z);
+        else
+            end_x = true;
+    } else
+        DoInterpolation(cur_z, envl_z, time, (float &)fill.mValue.z);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build linearly subsampled keys from three single envelopes, one for each component (x,y,z)
-void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
-    LWO::Envelope* _envl_x,
-    LWO::Envelope* _envl_y,
-    LWO::Envelope* _envl_z,
-    unsigned int _flags)
-{
+void AnimResolver::GetKeys(std::vector<aiVectorKey> &out,
+        LWO::Envelope *_envl_x,
+        LWO::Envelope *_envl_y,
+        LWO::Envelope *_envl_z,
+        unsigned int _flags) {
     envl_x = _envl_x;
     envl_y = _envl_y;
     envl_z = _envl_z;
-    flags  = _flags;
+    flags = _flags;
 
     // generate default channels if none are given
     LWO::Envelope def_x, def_y, def_z;
     LWO::Key key_dummy;
     key_dummy.time = 0.f;
     if ((envl_x && envl_x->type == LWO::EnvelopeType_Scaling_X) ||
-        (envl_y && envl_y->type == LWO::EnvelopeType_Scaling_Y) ||
-        (envl_z && envl_z->type == LWO::EnvelopeType_Scaling_Z)) {
+            (envl_y && envl_y->type == LWO::EnvelopeType_Scaling_Y) ||
+            (envl_z && envl_z->type == LWO::EnvelopeType_Scaling_Z)) {
         key_dummy.value = 1.f;
-    }
-    else key_dummy.value = 0.f;
+    } else
+        key_dummy.value = 0.f;
 
     if (!envl_x) {
         envl_x = &def_x;
@@ -437,15 +440,17 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
     if (flags & AI_LWO_ANIM_FLAG_SAMPLE_ANIMS) {
         if (!sample_rate)
             sr = 100.f;
-        else sr = sample_rate;
+        else
+            sr = sample_rate;
         sample_delta = 1.f / sr;
 
         reserve = (size_t)(
-            std::max( envl_x->keys.rbegin()->time,
-            std::max( envl_y->keys.rbegin()->time, envl_z->keys.rbegin()->time )) * sr);
-    }
-    else reserve = std::max(envl_x->keys.size(),std::max(envl_x->keys.size(),envl_z->keys.size()));
-    out.reserve(reserve+(reserve>>1));
+                std::max(envl_x->keys.rbegin()->time,
+                        std::max(envl_y->keys.rbegin()->time, envl_z->keys.rbegin()->time)) *
+                sr);
+    } else
+        reserve = std::max(envl_x->keys.size(), std::max(envl_x->keys.size(), envl_z->keys.size()));
+    out.reserve(reserve + (reserve >> 1));
 
     // Iterate through all three arrays at once - it's tricky, but
     // rather interesting to implement.
@@ -458,7 +463,7 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
 
         aiVectorKey fill;
 
-        if ((*cur_x).time == (*cur_y).time && (*cur_x).time == (*cur_z).time ) {
+        if ((*cur_x).time == (*cur_y).time && (*cur_x).time == (*cur_z).time) {
 
             // we have a keyframe for all of them defined .. this means
             // we don't need to interpolate here.
@@ -478,52 +483,49 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
         else if ((*cur_x).time <= (*cur_y).time && !end_x) {
 
             if ((*cur_z).time <= (*cur_x).time && !end_z) {
-                InterpolateTrack(out,fill,(*cur_z).time);
+                InterpolateTrack(out, fill, (*cur_z).time);
+            } else {
+                InterpolateTrack(out, fill, (*cur_x).time);
             }
-            else {
-                InterpolateTrack(out,fill,(*cur_x).time);
-            }
-        }
-        else if ((*cur_z).time <= (*cur_y).time && !end_y)  {
-            InterpolateTrack(out,fill,(*cur_y).time);
-        }
-        else if (!end_y) {
+        } else if ((*cur_z).time <= (*cur_y).time && !end_y) {
+            InterpolateTrack(out, fill, (*cur_y).time);
+        } else if (!end_y) {
             // welcome on the server, y
-            InterpolateTrack(out,fill,(*cur_y).time);
-        }
-        else {
+            InterpolateTrack(out, fill, (*cur_y).time);
+        } else {
             // we have reached the end of at least 2 channels,
             // only one is remaining. Extrapolate the 2.
             if (end_y) {
-                InterpolateTrack(out,fill,(end_x ? (*cur_z) : (*cur_x)).time);
-            }
-            else if (end_x) {
-                InterpolateTrack(out,fill,(end_z ? (*cur_y) : (*cur_z)).time);
-            }
-            else { // if (end_z)
-                InterpolateTrack(out,fill,(end_y ? (*cur_x) : (*cur_y)).time);
+                InterpolateTrack(out, fill, (end_x ? (*cur_z) : (*cur_x)).time);
+            } else if (end_x) {
+                InterpolateTrack(out, fill, (end_z ? (*cur_y) : (*cur_z)).time);
+            } else { // if (end_z)
+                InterpolateTrack(out, fill, (end_y ? (*cur_x) : (*cur_y)).time);
             }
         }
         double lasttime = fill.mTime;
         out.push_back(fill);
 
         if (lasttime >= (*cur_x).time) {
-            if (cur_x != envl_x->keys.end()-1)
+            if (cur_x != envl_x->keys.end() - 1)
                 ++cur_x;
-            else end_x = true;
+            else
+                end_x = true;
         }
         if (lasttime >= (*cur_y).time) {
-            if (cur_y != envl_y->keys.end()-1)
+            if (cur_y != envl_y->keys.end() - 1)
                 ++cur_y;
-            else end_y = true;
+            else
+                end_y = true;
         }
         if (lasttime >= (*cur_z).time) {
-            if (cur_z != envl_z->keys.end()-1)
+            if (cur_z != envl_z->keys.end() - 1)
                 ++cur_z;
-            else end_z = true;
+            else
+                end_z = true;
         }
 
-        if( end_x && end_y && end_z ) /* finished? */
+        if (end_x && end_y && end_z) /* finished? */
             break;
     }
 
@@ -535,11 +537,9 @@ void AnimResolver::GetKeys(std::vector<aiVectorKey>& out,
 
 // ------------------------------------------------------------------------------------------------
 // Extract animation channel
-void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int /*= 0*/)
-{
+void AnimResolver::ExtractAnimChannel(aiNodeAnim **out, unsigned int /*= 0*/) {
     *out = NULL;
 
-
     //FIXME: crashes if more than one component is animated at different timings, to be resolved.
 
     // If we have no envelopes, return NULL
@@ -555,7 +555,7 @@ void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int /*= 0*/)
         return;
 
     // Allocate the output animation
-    aiNodeAnim* anim = *out = new aiNodeAnim();
+    aiNodeAnim *anim = *out = new aiNodeAnim();
 
     // Setup default animation setup if necessary
     if (need_to_setup) {
@@ -566,41 +566,40 @@ void AnimResolver::ExtractAnimChannel(aiNodeAnim** out, unsigned int /*= 0*/)
     // copy translation keys
     if (trans) {
         std::vector<aiVectorKey> keys;
-        GetKeys(keys,trans_x,trans_y,trans_z,flags);
+        GetKeys(keys, trans_x, trans_y, trans_z, flags);
 
-        anim->mPositionKeys = new aiVectorKey[ anim->mNumPositionKeys = static_cast<unsigned int>(keys.size()) ];
-        std::copy(keys.begin(),keys.end(),anim->mPositionKeys);
+        anim->mPositionKeys = new aiVectorKey[anim->mNumPositionKeys = static_cast<unsigned int>(keys.size())];
+        std::copy(keys.begin(), keys.end(), anim->mPositionKeys);
     }
 
     // copy rotation keys
     if (rotat) {
         std::vector<aiVectorKey> keys;
-        GetKeys(keys,rotat_x,rotat_y,rotat_z,flags);
+        GetKeys(keys, rotat_x, rotat_y, rotat_z, flags);
 
-        anim->mRotationKeys = new aiQuatKey[ anim->mNumRotationKeys = static_cast<unsigned int>(keys.size()) ];
+        anim->mRotationKeys = new aiQuatKey[anim->mNumRotationKeys = static_cast<unsigned int>(keys.size())];
 
         // convert heading, pitch, bank to quaternion
         // mValue.x=Heading=Rot(Y), mValue.y=Pitch=Rot(X), mValue.z=Bank=Rot(Z)
         // Lightwave's rotation order is ZXY
-        aiVector3D X(1.0,0.0,0.0);
-        aiVector3D Y(0.0,1.0,0.0);
-        aiVector3D Z(0.0,0.0,1.0);
+        aiVector3D X(1.0, 0.0, 0.0);
+        aiVector3D Y(0.0, 1.0, 0.0);
+        aiVector3D Z(0.0, 0.0, 1.0);
         for (unsigned int i = 0; i < anim->mNumRotationKeys; ++i) {
-            aiQuatKey& qk = anim->mRotationKeys[i];
-            qk.mTime  = keys[i].mTime;
-            qk.mValue = aiQuaternion(Y,keys[i].mValue.x)*aiQuaternion(X,keys[i].mValue.y)*aiQuaternion(Z,keys[i].mValue.z);
+            aiQuatKey &qk = anim->mRotationKeys[i];
+            qk.mTime = keys[i].mTime;
+            qk.mValue = aiQuaternion(Y, keys[i].mValue.x) * aiQuaternion(X, keys[i].mValue.y) * aiQuaternion(Z, keys[i].mValue.z);
         }
     }
 
     // copy scaling keys
     if (scale) {
         std::vector<aiVectorKey> keys;
-        GetKeys(keys,scale_x,scale_y,scale_z,flags);
+        GetKeys(keys, scale_x, scale_y, scale_z, flags);
 
-        anim->mScalingKeys = new aiVectorKey[ anim->mNumScalingKeys = static_cast<unsigned int>(keys.size()) ];
-        std::copy(keys.begin(),keys.end(),anim->mScalingKeys);
+        anim->mScalingKeys = new aiVectorKey[anim->mNumScalingKeys = static_cast<unsigned int>(keys.size())];
+        std::copy(keys.begin(), keys.end(), anim->mScalingKeys);
     }
 }
 
-
 #endif // no lwo or no lws
diff --git a/code/LWO/LWOAnimation.h b/code/AssetLib/LWO/LWOAnimation.h
similarity index 100%
rename from code/LWO/LWOAnimation.h
rename to code/AssetLib/LWO/LWOAnimation.h
diff --git a/code/LWO/LWOBLoader.cpp b/code/AssetLib/LWO/LWOBLoader.cpp
similarity index 100%
rename from code/LWO/LWOBLoader.cpp
rename to code/AssetLib/LWO/LWOBLoader.cpp
diff --git a/code/AssetLib/LWO/LWOFileData.h b/code/AssetLib/LWO/LWOFileData.h
new file mode 100644
index 000000000..4f85fc5f4
--- /dev/null
+++ b/code/AssetLib/LWO/LWOFileData.h
@@ -0,0 +1,638 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2020, 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 LWOFileData.h
+ *  @brief Defines chunk constants used by the LWO file format
+
+The chunks are taken from the official LightWave SDK headers.
+
+*/
+#ifndef AI_LWO_FILEDATA_INCLUDED
+#define AI_LWO_FILEDATA_INCLUDED
+
+// STL headers
+#include <list>
+#include <vector>
+
+// public ASSIMP headers
+#include <assimp/mesh.h>
+
+// internal headers
+#include "AssetLib/LWO/LWOAnimation.h"
+#include "Common/IFF.h"
+
+namespace Assimp {
+namespace LWO {
+
+#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L', 'W', 'O', 'B')
+#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L', 'W', 'O', '2')
+#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L', 'X', 'O', 'B')
+
+// chunks specific to the LWOB format
+#define AI_LWO_SRFS AI_IFF_FOURCC('S', 'R', 'F', 'S')
+#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G')
+#define AI_LWO_VLUM AI_IFF_FOURCC('V', 'L', 'U', 'M')
+#define AI_LWO_VDIF AI_IFF_FOURCC('V', 'D', 'I', 'F')
+#define AI_LWO_VSPC AI_IFF_FOURCC('V', 'S', 'P', 'C')
+#define AI_LWO_RFLT AI_IFF_FOURCC('R', 'F', 'L', 'T')
+#define AI_LWO_BTEX AI_IFF_FOURCC('B', 'T', 'E', 'X')
+#define AI_LWO_CTEX AI_IFF_FOURCC('C', 'T', 'E', 'X')
+#define AI_LWO_DTEX AI_IFF_FOURCC('D', 'T', 'E', 'X')
+#define AI_LWO_LTEX AI_IFF_FOURCC('L', 'T', 'E', 'X')
+#define AI_LWO_RTEX AI_IFF_FOURCC('R', 'T', 'E', 'X')
+#define AI_LWO_STEX AI_IFF_FOURCC('S', 'T', 'E', 'X')
+#define AI_LWO_TTEX AI_IFF_FOURCC('T', 'T', 'E', 'X')
+#define AI_LWO_TFLG AI_IFF_FOURCC('T', 'F', 'L', 'G')
+#define AI_LWO_TSIZ AI_IFF_FOURCC('T', 'S', 'I', 'Z')
+#define AI_LWO_TCTR AI_IFF_FOURCC('T', 'C', 'T', 'R')
+#define AI_LWO_TFAL AI_IFF_FOURCC('T', 'F', 'A', 'L')
+#define AI_LWO_TVEL AI_IFF_FOURCC('T', 'V', 'E', 'L')
+#define AI_LWO_TCLR AI_IFF_FOURCC('T', 'C', 'L', 'R')
+#define AI_LWO_TVAL AI_IFF_FOURCC('T', 'V', 'A', 'L')
+#define AI_LWO_TAMP AI_IFF_FOURCC('T', 'A', 'M', 'P')
+#define AI_LWO_TIMG AI_IFF_FOURCC('T', 'I', 'M', 'G')
+#define AI_LWO_TAAS AI_IFF_FOURCC('T', 'A', 'A', 'S')
+#define AI_LWO_TREF AI_IFF_FOURCC('T', 'R', 'E', 'F')
+#define AI_LWO_TOPC AI_IFF_FOURCC('T', 'O', 'P', 'C')
+#define AI_LWO_SDAT AI_IFF_FOURCC('S', 'D', 'A', 'T')
+#define AI_LWO_TFP0 AI_IFF_FOURCC('T', 'F', 'P', '0')
+#define AI_LWO_TFP1 AI_IFF_FOURCC('T', 'F', 'P', '1')
+
+/* top-level chunks */
+#define AI_LWO_LAYR AI_IFF_FOURCC('L', 'A', 'Y', 'R')
+#define AI_LWO_TAGS AI_IFF_FOURCC('T', 'A', 'G', 'S')
+#define AI_LWO_PNTS AI_IFF_FOURCC('P', 'N', 'T', 'S')
+#define AI_LWO_BBOX AI_IFF_FOURCC('B', 'B', 'O', 'X')
+#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P')
+#define AI_LWO_VMAD AI_IFF_FOURCC('V', 'M', 'A', 'D')
+#define AI_LWO_POLS AI_IFF_FOURCC('P', 'O', 'L', 'S')
+#define AI_LWO_PTAG AI_IFF_FOURCC('P', 'T', 'A', 'G')
+#define AI_LWO_ENVL AI_IFF_FOURCC('E', 'N', 'V', 'L')
+#define AI_LWO_CLIP AI_IFF_FOURCC('C', 'L', 'I', 'P')
+#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F')
+#define AI_LWO_DESC AI_IFF_FOURCC('D', 'E', 'S', 'C')
+#define AI_LWO_TEXT AI_IFF_FOURCC('T', 'E', 'X', 'T')
+#define AI_LWO_ICON AI_IFF_FOURCC('I', 'C', 'O', 'N')
+
+/* polygon types */
+#define AI_LWO_FACE AI_IFF_FOURCC('F', 'A', 'C', 'E')
+#define AI_LWO_CURV AI_IFF_FOURCC('C', 'U', 'R', 'V')
+#define AI_LWO_PTCH AI_IFF_FOURCC('P', 'T', 'C', 'H')
+#define AI_LWO_MBAL AI_IFF_FOURCC('M', 'B', 'A', 'L')
+#define AI_LWO_BONE AI_IFF_FOURCC('B', 'O', 'N', 'E')
+#define AI_LWO_SUBD AI_IFF_FOURCC('S', 'U', 'B', 'D')
+
+/* polygon tags */
+#define AI_LWO_SURF AI_IFF_FOURCC('S', 'U', 'R', 'F')
+#define AI_LWO_PART AI_IFF_FOURCC('P', 'A', 'R', 'T')
+#define AI_LWO_SMGP AI_IFF_FOURCC('S', 'M', 'G', 'P')
+
+/* envelopes */
+#define AI_LWO_PRE AI_IFF_FOURCC('P', 'R', 'E', ' ')
+#define AI_LWO_POST AI_IFF_FOURCC('P', 'O', 'S', 'T')
+#define AI_LWO_KEY AI_IFF_FOURCC('K', 'E', 'Y', ' ')
+#define AI_LWO_SPAN AI_IFF_FOURCC('S', 'P', 'A', 'N')
+#define AI_LWO_TCB AI_IFF_FOURCC('T', 'C', 'B', ' ')
+#define AI_LWO_HERM AI_IFF_FOURCC('H', 'E', 'R', 'M')
+#define AI_LWO_BEZI AI_IFF_FOURCC('B', 'E', 'Z', 'I')
+#define AI_LWO_BEZ2 AI_IFF_FOURCC('B', 'E', 'Z', '2')
+#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E')
+#define AI_LWO_STEP AI_IFF_FOURCC('S', 'T', 'E', 'P')
+
+/* clips */
+#define AI_LWO_STIL AI_IFF_FOURCC('S', 'T', 'I', 'L')
+#define AI_LWO_ISEQ AI_IFF_FOURCC('I', 'S', 'E', 'Q')
+#define AI_LWO_ANIM AI_IFF_FOURCC('A', 'N', 'I', 'M')
+#define AI_LWO_XREF AI_IFF_FOURCC('X', 'R', 'E', 'F')
+#define AI_LWO_STCC AI_IFF_FOURCC('S', 'T', 'C', 'C')
+#define AI_LWO_TIME AI_IFF_FOURCC('T', 'I', 'M', 'E')
+#define AI_LWO_CONT AI_IFF_FOURCC('C', 'O', 'N', 'T')
+#define AI_LWO_BRIT AI_IFF_FOURCC('B', 'R', 'I', 'T')
+#define AI_LWO_SATR AI_IFF_FOURCC('S', 'A', 'T', 'R')
+#define AI_LWO_HUE AI_IFF_FOURCC('H', 'U', 'E', ' ')
+#define AI_LWO_GAMM AI_IFF_FOURCC('G', 'A', 'M', 'M')
+#define AI_LWO_NEGA AI_IFF_FOURCC('N', 'E', 'G', 'A')
+#define AI_LWO_IFLT AI_IFF_FOURCC('I', 'F', 'L', 'T')
+#define AI_LWO_PFLT AI_IFF_FOURCC('P', 'F', 'L', 'T')
+
+/* surfaces */
+#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R')
+#define AI_LWO_LUMI AI_IFF_FOURCC('L', 'U', 'M', 'I')
+#define AI_LWO_DIFF AI_IFF_FOURCC('D', 'I', 'F', 'F')
+#define AI_LWO_SPEC AI_IFF_FOURCC('S', 'P', 'E', 'C')
+#define AI_LWO_GLOS AI_IFF_FOURCC('G', 'L', 'O', 'S')
+#define AI_LWO_REFL AI_IFF_FOURCC('R', 'E', 'F', 'L')
+#define AI_LWO_RFOP AI_IFF_FOURCC('R', 'F', 'O', 'P')
+#define AI_LWO_RIMG AI_IFF_FOURCC('R', 'I', 'M', 'G')
+#define AI_LWO_RSAN AI_IFF_FOURCC('R', 'S', 'A', 'N')
+#define AI_LWO_TRAN AI_IFF_FOURCC('T', 'R', 'A', 'N')
+#define AI_LWO_TROP AI_IFF_FOURCC('T', 'R', 'O', 'P')
+#define AI_LWO_TIMG AI_IFF_FOURCC('T', 'I', 'M', 'G')
+#define AI_LWO_RIND AI_IFF_FOURCC('R', 'I', 'N', 'D')
+#define AI_LWO_TRNL AI_IFF_FOURCC('T', 'R', 'N', 'L')
+#define AI_LWO_BUMP AI_IFF_FOURCC('B', 'U', 'M', 'P')
+#define AI_LWO_SMAN AI_IFF_FOURCC('S', 'M', 'A', 'N')
+#define AI_LWO_SIDE AI_IFF_FOURCC('S', 'I', 'D', 'E')
+#define AI_LWO_CLRH AI_IFF_FOURCC('C', 'L', 'R', 'H')
+#define AI_LWO_CLRF AI_IFF_FOURCC('C', 'L', 'R', 'F')
+#define AI_LWO_ADTR AI_IFF_FOURCC('A', 'D', 'T', 'R')
+#define AI_LWO_SHRP AI_IFF_FOURCC('S', 'H', 'R', 'P')
+#define AI_LWO_LINE AI_IFF_FOURCC('L', 'I', 'N', 'E')
+#define AI_LWO_LSIZ AI_IFF_FOURCC('L', 'S', 'I', 'Z')
+#define AI_LWO_ALPH AI_IFF_FOURCC('A', 'L', 'P', 'H')
+#define AI_LWO_AVAL AI_IFF_FOURCC('A', 'V', 'A', 'L')
+#define AI_LWO_GVAL AI_IFF_FOURCC('G', 'V', 'A', 'L')
+#define AI_LWO_BLOK AI_IFF_FOURCC('B', 'L', 'O', 'K')
+#define AI_LWO_VCOL AI_IFF_FOURCC('V', 'C', 'O', 'L')
+
+/* texture layer */
+#define AI_LWO_TYPE AI_IFF_FOURCC('T', 'Y', 'P', 'E')
+#define AI_LWO_CHAN AI_IFF_FOURCC('C', 'H', 'A', 'N')
+#define AI_LWO_NAME AI_IFF_FOURCC('N', 'A', 'M', 'E')
+#define AI_LWO_ENAB AI_IFF_FOURCC('E', 'N', 'A', 'B')
+#define AI_LWO_OPAC AI_IFF_FOURCC('O', 'P', 'A', 'C')
+#define AI_LWO_FLAG AI_IFF_FOURCC('F', 'L', 'A', 'G')
+#define AI_LWO_PROJ AI_IFF_FOURCC('P', 'R', 'O', 'J')
+#define AI_LWO_STCK AI_IFF_FOURCC('S', 'T', 'C', 'K')
+#define AI_LWO_TAMP AI_IFF_FOURCC('T', 'A', 'M', 'P')
+
+/* texture coordinates */
+#define AI_LWO_TMAP AI_IFF_FOURCC('T', 'M', 'A', 'P')
+#define AI_LWO_AXIS AI_IFF_FOURCC('A', 'X', 'I', 'S')
+#define AI_LWO_CNTR AI_IFF_FOURCC('C', 'N', 'T', 'R')
+#define AI_LWO_SIZE AI_IFF_FOURCC('S', 'I', 'Z', 'E')
+#define AI_LWO_ROTA AI_IFF_FOURCC('R', 'O', 'T', 'A')
+#define AI_LWO_OREF AI_IFF_FOURCC('O', 'R', 'E', 'F')
+#define AI_LWO_FALL AI_IFF_FOURCC('F', 'A', 'L', 'L')
+#define AI_LWO_CSYS AI_IFF_FOURCC('C', 'S', 'Y', 'S')
+
+/* image map */
+#define AI_LWO_IMAP AI_IFF_FOURCC('I', 'M', 'A', 'P')
+#define AI_LWO_IMAG AI_IFF_FOURCC('I', 'M', 'A', 'G')
+#define AI_LWO_WRAP AI_IFF_FOURCC('W', 'R', 'A', 'P')
+#define AI_LWO_WRPW AI_IFF_FOURCC('W', 'R', 'P', 'W')
+#define AI_LWO_WRPH AI_IFF_FOURCC('W', 'R', 'P', 'H')
+#define AI_LWO_VMAP AI_IFF_FOURCC('V', 'M', 'A', 'P')
+#define AI_LWO_AAST AI_IFF_FOURCC('A', 'A', 'S', 'T')
+#define AI_LWO_PIXB AI_IFF_FOURCC('P', 'I', 'X', 'B')
+
+/* procedural */
+#define AI_LWO_PROC AI_IFF_FOURCC('P', 'R', 'O', 'C')
+#define AI_LWO_COLR AI_IFF_FOURCC('C', 'O', 'L', 'R')
+#define AI_LWO_VALU AI_IFF_FOURCC('V', 'A', 'L', 'U')
+#define AI_LWO_FUNC AI_IFF_FOURCC('F', 'U', 'N', 'C')
+#define AI_LWO_FTPS AI_IFF_FOURCC('F', 'T', 'P', 'S')
+#define AI_LWO_ITPS AI_IFF_FOURCC('I', 'T', 'P', 'S')
+#define AI_LWO_ETPS AI_IFF_FOURCC('E', 'T', 'P', 'S')
+
+/* gradient */
+#define AI_LWO_GRAD AI_IFF_FOURCC('G', 'R', 'A', 'D')
+#define AI_LWO_GRST AI_IFF_FOURCC('G', 'R', 'S', 'T')
+#define AI_LWO_GREN AI_IFF_FOURCC('G', 'R', 'E', 'N')
+#define AI_LWO_PNAM AI_IFF_FOURCC('P', 'N', 'A', 'M')
+#define AI_LWO_INAM AI_IFF_FOURCC('I', 'N', 'A', 'M')
+#define AI_LWO_GRPT AI_IFF_FOURCC('G', 'R', 'P', 'T')
+#define AI_LWO_FKEY AI_IFF_FOURCC('F', 'K', 'E', 'Y')
+#define AI_LWO_IKEY AI_IFF_FOURCC('I', 'K', 'E', 'Y')
+
+/* shader */
+#define AI_LWO_SHDR AI_IFF_FOURCC('S', 'H', 'D', 'R')
+#define AI_LWO_DATA AI_IFF_FOURCC('D', 'A', 'T', 'A')
+
+/* VMAP types */
+#define AI_LWO_TXUV AI_IFF_FOURCC('T', 'X', 'U', 'V')
+#define AI_LWO_RGB AI_IFF_FOURCC('R', 'G', 'B', ' ')
+#define AI_LWO_RGBA AI_IFF_FOURCC('R', 'G', 'B', 'A')
+#define AI_LWO_WGHT AI_IFF_FOURCC('W', 'G', 'H', 'T')
+
+#define AI_LWO_MNVW AI_IFF_FOURCC('M', 'N', 'V', 'W')
+#define AI_LWO_MORF AI_IFF_FOURCC('M', 'O', 'R', 'F')
+#define AI_LWO_SPOT AI_IFF_FOURCC('S', 'P', 'O', 'T')
+#define AI_LWO_PICK AI_IFF_FOURCC('P', 'I', 'C', 'K')
+
+// MODO extension - per-vertex normal vectors
+#define AI_LWO_MODO_NORM AI_IFF_FOURCC('N', 'O', 'R', 'M')
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a face in a LWO file
+ *
+ * \note We can't use the code in SmoothingGroups.inl here - the mesh
+ *   structures of 3DS/ASE and LWO are too different.
+ */
+struct Face : public aiFace {
+    //! Default construction
+    Face() AI_NO_EXCEPT
+            : surfaceIndex(0),
+              smoothGroup(0),
+              type(AI_LWO_FACE) {
+        // empty
+    }
+
+    //! Construction from given type
+    explicit Face(uint32_t _type) :
+            surfaceIndex(0), smoothGroup(0), type(_type) {}
+
+    //! Copy construction
+    Face(const Face &f) :
+            aiFace() {
+        *this = f;
+    }
+
+    //! Zero-based index into tags chunk
+    unsigned int surfaceIndex;
+
+    //! Smooth group this face is assigned to
+    unsigned int smoothGroup;
+
+    //! Type of face
+    uint32_t type;
+
+    //! Assignment operator
+    Face &operator=(const LWO::Face &f) {
+        aiFace::operator=(f);
+        surfaceIndex = f.surfaceIndex;
+        smoothGroup = f.smoothGroup;
+        type = f.type;
+        return *this;
+    }
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Base structure for all vertex map representations
+ */
+struct VMapEntry {
+    explicit VMapEntry(unsigned int _dims) :
+            dims(_dims) {}
+
+    virtual ~VMapEntry() {}
+
+    //! allocates memory for the vertex map
+    virtual void Allocate(unsigned int num) {
+        if (!rawData.empty())
+            return; // return if already allocated
+
+        const unsigned int m = num * dims;
+        rawData.reserve(m + (m >> 2u)); // 25% as  extra storage for VMADs
+        rawData.resize(m, 0.f);
+        abAssigned.resize(num, false);
+    }
+
+    std::string name;
+    unsigned int dims;
+
+    std::vector<float> rawData;
+    std::vector<bool> abAssigned;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents an extra vertex color channel
+ */
+struct VColorChannel : public VMapEntry {
+    VColorChannel() :
+            VMapEntry(4) {}
+
+    //! need to overwrite this function - the alpha channel must
+    //! be initialized to 1.0 by default
+    virtual void Allocate(unsigned int num) {
+        if (!rawData.empty())
+            return; // return if already allocated
+
+        unsigned int m = num * dims;
+        rawData.reserve(m + (m >> 2u)); // 25% as  extra storage for VMADs
+        rawData.resize(m);
+
+        for (aiColor4D *p = (aiColor4D *)&rawData[0]; p < (aiColor4D *)&rawData[m - 1]; ++p)
+            p->a = 1.f;
+
+        abAssigned.resize(num, false);
+    }
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents an extra vertex UV channel
+ */
+struct UVChannel : public VMapEntry {
+    UVChannel() :
+            VMapEntry(2) {}
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents a weight map
+ */
+struct WeightChannel : public VMapEntry {
+    WeightChannel() :
+            VMapEntry(1) {}
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Represents a vertex-normals channel (MODO extension)
+ */
+struct NormalChannel : public VMapEntry {
+    NormalChannel() :
+            VMapEntry(3) {}
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file texture
+ */
+struct Texture {
+    // we write the enum values out here to make debugging easier ...
+    enum BlendType {
+        Normal = 0,
+        Subtractive = 1,
+        Difference = 2,
+        Multiply = 3,
+        Divide = 4,
+        Alpha = 5,
+        TextureDispl = 6,
+        Additive = 7
+    };
+
+    enum MappingMode {
+        Planar = 0,
+        Cylindrical = 1,
+        Spherical = 2,
+        Cubic = 3,
+        FrontProjection = 4,
+        UV = 5
+    };
+
+    enum Axes {
+        AXIS_X = 0,
+        AXIS_Y = 1,
+        AXIS_Z = 2
+    };
+
+    enum Wrap {
+        RESET = 0,
+        REPEAT = 1,
+        MIRROR = 2,
+        EDGE = 3
+    };
+
+    Texture() :
+            mClipIdx(UINT_MAX), mStrength(1.0f), type(), mUVChannelIndex("unknown"), mRealUVIndex(UINT_MAX), enabled(true), blendType(Additive), bCanUse(true), mapMode(UV), majorAxis(AXIS_X), wrapAmountH(1.0f), wrapAmountW(1.0f), wrapModeWidth(REPEAT), wrapModeHeight(REPEAT), ordinal("\x00") {}
+
+    //! File name of the texture
+    std::string mFileName;
+
+    //! Clip index
+    unsigned int mClipIdx;
+
+    //! Strength of the texture - blend factor
+    float mStrength;
+
+    uint32_t type; // type of the texture
+
+    //! Name of the corresponding UV channel
+    std::string mUVChannelIndex;
+    unsigned int mRealUVIndex;
+
+    //! is the texture enabled?
+    bool enabled;
+
+    //! blend type
+    BlendType blendType;
+
+    //! are we able to use the texture?
+    bool bCanUse;
+
+    //! mapping mode
+    MappingMode mapMode;
+
+    //! major axis for planar, cylindrical, spherical projections
+    Axes majorAxis;
+
+    //! wrap amount for cylindrical and spherical projections
+    float wrapAmountH, wrapAmountW;
+
+    //! wrapping mode for the texture
+    Wrap wrapModeWidth, wrapModeHeight;
+
+    //! ordinal string of the texture
+    std::string ordinal;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file clip
+ */
+struct Clip {
+    enum Type {
+        STILL,
+        SEQ,
+        REF,
+        UNSUPPORTED
+    } type;
+
+    Clip() :
+            type(UNSUPPORTED), clipRef(), idx(0), negate(false) {}
+
+    //! path to the base texture -
+    std::string path;
+
+    //! reference to another CLIP
+    unsigned int clipRef;
+
+    //! index of the clip
+    unsigned int idx;
+
+    //! Negate the clip?
+    bool negate;
+};
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file shader
+ *
+ *  Later
+ */
+struct Shader {
+    Shader() :
+            ordinal("\x00"), functionName("unknown"), enabled(true) {}
+
+    std::string ordinal;
+    std::string functionName;
+    bool enabled;
+};
+
+typedef std::list<Texture> TextureList;
+typedef std::list<Shader> ShaderList;
+
+// ---------------------------------------------------------------------------
+/** \brief Data structure for a LWO file surface (= material)
+ */
+struct Surface {
+    Surface() :
+            mColor(0.78431f, 0.78431f, 0.78431f), bDoubleSided(false), mDiffuseValue(1.f), mSpecularValue(0.f), mTransparency(0.f), mGlossiness(0.4f), mLuminosity(0.f), mColorHighlights(0.f), mMaximumSmoothAngle(0.f) // 0 == not specified, no smoothing
+            ,
+            mVCMap(""),
+            mVCMapType(AI_LWO_RGBA),
+            mIOR(1.f) // vakuum
+            ,
+            mBumpIntensity(1.f),
+            mWireframe(false),
+            mAdditiveTransparency(0.f) {}
+
+    //! Name of the surface
+    std::string mName;
+
+    //! Color of the surface
+    aiColor3D mColor;
+
+    //! true for two-sided materials
+    bool bDoubleSided;
+
+    //! Various material parameters
+    float mDiffuseValue, mSpecularValue, mTransparency, mGlossiness, mLuminosity, mColorHighlights;
+
+    //! Maximum angle between two adjacent triangles
+    //! that they can be smoothed - in degrees
+    float mMaximumSmoothAngle;
+
+    //! Vertex color map to be used to color the surface
+    std::string mVCMap;
+    uint32_t mVCMapType;
+
+    //! Names of the special shaders to be applied to the surface
+    ShaderList mShaders;
+
+    //! Textures - the first entry in the list is evaluated first
+    TextureList mColorTextures, // color textures are added to both diffuse and specular texture stacks
+            mDiffuseTextures,
+            mSpecularTextures,
+            mOpacityTextures,
+            mBumpTextures,
+            mGlossinessTextures,
+            mReflectionTextures;
+
+    //! Index of refraction
+    float mIOR;
+
+    //! Bump intensity scaling
+    float mBumpIntensity;
+
+    //! Wireframe flag
+    bool mWireframe;
+
+    //! Intensity of additive blending
+    float mAdditiveTransparency;
+};
+
+// ---------------------------------------------------------------------------
+#define AI_LWO_VALIDATE_CHUNK_LENGTH(length, name, size)              \
+    if (length < size) {                                              \
+        throw DeadlyImportError("LWO: " #name " chunk is too small"); \
+    }
+
+// some typedefs ... to make life with loader monsters like this easier
+typedef std::vector<aiVector3D> PointList;
+typedef std::vector<LWO::Face> FaceList;
+typedef std::vector<LWO::Surface> SurfaceList;
+typedef std::vector<std::string> TagList;
+typedef std::vector<unsigned int> TagMappingTable;
+typedef std::vector<unsigned int> ReferrerList;
+typedef std::vector<WeightChannel> WeightChannelList;
+typedef std::vector<VColorChannel> VColorChannelList;
+typedef std::vector<UVChannel> UVChannelList;
+typedef std::vector<Clip> ClipList;
+typedef std::vector<Envelope> EnvelopeList;
+typedef std::vector<unsigned int> SortedRep;
+
+// ---------------------------------------------------------------------------
+/** \brief Represents a layer in the file
+ */
+struct Layer {
+    Layer() :
+            mFaceIDXOfs(0), mPointIDXOfs(0), mParent(0x0), mIndex(0xffff), skip(false) {}
+
+    /** Temporary point list from the file */
+    PointList mTempPoints;
+
+    /** Lists for every point the index of another point
+        that has been copied from *this* point or UINT_MAX if
+        no copy of the point has been made */
+    ReferrerList mPointReferrers;
+
+    /** Weight channel list from the file */
+    WeightChannelList mWeightChannels;
+
+    /** Subdivision weight channel list from the file */
+    WeightChannelList mSWeightChannels;
+
+    /** Vertex color list from the file */
+    VColorChannelList mVColorChannels;
+
+    /** UV channel list from the file */
+    UVChannelList mUVChannels;
+
+    /** Normal vector channel from the file */
+    NormalChannel mNormals;
+
+    /** Temporary face list from the file*/
+    FaceList mFaces;
+
+    /** Current face indexing offset from the beginning of the buffers*/
+    unsigned int mFaceIDXOfs;
+
+    /** Current point indexing offset from the beginning of the buffers*/
+    unsigned int mPointIDXOfs;
+
+    /** Parent index */
+    uint16_t mParent;
+
+    /** Index of the layer */
+    uint16_t mIndex;
+
+    /** Name of the layer */
+    std::string mName;
+
+    /** Pivot point of the layer */
+    aiVector3D mPivot;
+
+    /** Skip this layer? */
+    bool skip;
+};
+
+typedef std::list<LWO::Layer> LayerList;
+
+} // namespace LWO
+} // namespace Assimp
+
+#endif // !! AI_LWO_FILEDATA_INCLUDED
diff --git a/code/LWO/LWOLoader.cpp b/code/AssetLib/LWO/LWOLoader.cpp
similarity index 99%
rename from code/LWO/LWOLoader.cpp
rename to code/AssetLib/LWO/LWOLoader.cpp
index 7e3db6bd0..7a9738228 100644
--- a/code/LWO/LWOLoader.cpp
+++ b/code/AssetLib/LWO/LWOLoader.cpp
@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
 
 // internal headers
-#include "LWO/LWOLoader.h"
+#include "AssetLib/LWO/LWOLoader.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 #include "PostProcessing/ProcessHelper.h"
 
diff --git a/code/LWO/LWOLoader.h b/code/AssetLib/LWO/LWOLoader.h
similarity index 100%
rename from code/LWO/LWOLoader.h
rename to code/AssetLib/LWO/LWOLoader.h
diff --git a/code/LWO/LWOMaterial.cpp b/code/AssetLib/LWO/LWOMaterial.cpp
similarity index 100%
rename from code/LWO/LWOMaterial.cpp
rename to code/AssetLib/LWO/LWOMaterial.cpp
diff --git a/code/LWS/LWSLoader.cpp b/code/AssetLib/LWS/LWSLoader.cpp
similarity index 94%
rename from code/LWS/LWSLoader.cpp
rename to code/AssetLib/LWS/LWSLoader.cpp
index 952c3ccbc..baa90d786 100644
--- a/code/LWS/LWSLoader.cpp
+++ b/code/AssetLib/LWS/LWSLoader.cpp
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -47,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_LWS_IMPORTER
 
-#include "LWS/LWSLoader.h"
+#include "AssetLib/LWS/LWSLoader.h"
 #include "Common/Importer.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
@@ -117,13 +115,15 @@ void LWS::Element::Parse(const char *&buffer) {
         }
 
         cur = buffer;
-        while (!IsLineEnd(*buffer))
+        while (!IsLineEnd(*buffer)) {
             ++buffer;
+        }
         children.back().tokens[1] = std::string(cur, (size_t)(buffer - cur));
 
         // parse more elements recursively
-        if (sub)
+        if (sub) {
             children.back().Parse(buffer);
+        }
     }
 }
 
@@ -149,8 +149,9 @@ LWSImporter::~LWSImporter() {
 // Returns whether the class can handle the format of the given file.
 bool LWSImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
     const std::string extension = GetExtension(pFile);
-    if (extension == "lws" || extension == "mot")
+    if (extension == "lws" || extension == "mot") {
         return true;
+    }
 
     // if check for extension is not enough, check for the magic tokens LWSC and LWMO
     if (!extension.length() || checkSig) {
@@ -199,7 +200,7 @@ void LWSImporter::ReadEnvelope(const LWS::Element &dad, LWO::Envelope &fill) {
 
     // reserve enough storage
     std::list<LWS::Element>::const_iterator it = dad.children.begin();
-    ;
+    
     fill.keys.reserve(strtoul10(it->tokens[1].c_str()));
 
     for (++it; it != dad.children.end(); ++it) {
@@ -219,7 +220,6 @@ void LWSImporter::ReadEnvelope(const LWS::Element &dad, LWO::Envelope &fill) {
 
             unsigned int span = strtoul10(c, &c), num = 0;
             switch (span) {
-
                 case 0:
                     key.inter = LWO::IT_TCB;
                     num = 5;
@@ -276,7 +276,9 @@ void LWSImporter::ReadEnvelope_Old(
         envl.index = i;
         envl.type = (LWO::EnvelopeType)(i + 1);
 
-        if (++it == end) goto unexpected_end;
+        if (++it == end) {
+            goto unexpected_end;
+        }
         sub_num = strtoul10((*it).tokens[0].c_str());
 
         for (unsigned int n = 0; n < sub_num; ++n) {
@@ -311,10 +313,11 @@ void LWSImporter::SetupNodeName(aiNode *nd, LWS::NodeDesc &src) {
 
         if (src.path.length()) {
             std::string::size_type s = src.path.find_last_of("\\/");
-            if (s == std::string::npos)
+            if (s == std::string::npos) {
                 s = 0;
-            else
+            } else {
                 ++s;
+            }
             std::string::size_type t = src.path.substr(s).find_last_of(".");
 
             nd->mName.length = ::ai_snprintf(nd->mName.data, MAXLEN, "%s_(%08X)", src.path.substr(s).substr(0, t).c_str(), combined);
@@ -325,7 +328,7 @@ void LWSImporter::SetupNodeName(aiNode *nd, LWS::NodeDesc &src) {
 }
 
 // ------------------------------------------------------------------------------------------------
-// Recursively build the scenegraph
+// Recursively build the scene-graph
 void LWSImporter::BuildGraph(aiNode *nd, LWS::NodeDesc &src, std::vector<AttachmentInfo> &attach,
         BatchLoader &batch,
         aiCamera **&camOut,
@@ -409,20 +412,19 @@ void LWSImporter::BuildGraph(aiNode *nd, LWS::NodeDesc &src, std::vector<Attachm
 
         } else if (src.lightType == 1) { /* directional light source */
             lit->mType = aiLightSource_DIRECTIONAL;
-        } else
+        } else {
             lit->mType = aiLightSource_POINT;
+        }
 
         // fixme: no proper handling of light falloffs yet
-        if (src.lightFalloffType == 1)
+        if (src.lightFalloffType == 1) {
             lit->mAttenuationConstant = 1.f;
-        else if (src.lightFalloffType == 1)
+        } else if (src.lightFalloffType == 2) {
             lit->mAttenuationLinear = 1.f;
-        else
+        } else {
             lit->mAttenuationQuadratic = 1.f;
-    }
-
-    // If object is a camera - setup a corresponding ai structure
-    else if (src.type == LWS::NodeDesc::CAMERA) {
+        }
+    } else if (src.type == LWS::NodeDesc::CAMERA) { // If object is a camera - setup a corresponding ai structure
         aiCamera *cam = *camOut++ = new aiCamera();
 
         // name to attach cam to node -> unique due to LWs indexing system
@@ -434,7 +436,7 @@ void LWSImporter::BuildGraph(aiNode *nd, LWS::NodeDesc &src, std::vector<Attachm
     resolver.ExtractBindPose(ndAnim->mTransformation);
 
     // .. and construct animation channels
-    aiNodeAnim *anim = NULL;
+    aiNodeAnim *anim = nullptr;
 
     if (first != last) {
         resolver.SetAnimationRange(first, last);
@@ -461,11 +463,10 @@ void LWSImporter::BuildGraph(aiNode *nd, LWS::NodeDesc &src, std::vector<Attachm
 // Determine the exact location of a LWO file
 std::string LWSImporter::FindLWOFile(const std::string &in) {
     // insert missing directory separator if necessary
-    std::string tmp;
+    std::string tmp(in);
     if (in.length() > 3 && in[1] == ':' && in[2] != '\\' && in[2] != '/') {
         tmp = in[0] + (std::string(":\\") + in.substr(2));
-    } else
-        tmp = in;
+    } 
 
     if (io->Exists(tmp)) {
         return in;
@@ -495,13 +496,12 @@ std::string LWSImporter::FindLWOFile(const std::string &in) {
 
 // ------------------------------------------------------------------------------------------------
 // Read file into given scene data structure
-void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
-        IOSystem *pIOHandler) {
+void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler) {
     io = pIOHandler;
     std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
     // Check whether we can read from the file
-    if (file.get() == NULL) {
+    if (file.get() == nullptr) {
         throw DeadlyImportError("Failed to open LWS file " + pFile + ".");
     }
 
@@ -514,9 +514,8 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
     const char *dummy = &mBuffer[0];
     root.Parse(dummy);
 
-    // Construct a Batchimporter to read more files recursively
+    // Construct a Batch-importer to read more files recursively
     BatchLoader batch(pIOHandler);
-    //  batch.SetBasePath(pFile);
 
     // Construct an array to receive the flat output graph
     std::list<LWS::NodeDesc> nodes;
@@ -528,11 +527,13 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
     bool motion_file = false;
     std::list<LWS::Element>::const_iterator it = root.children.begin();
 
-    if ((*it).tokens[0] == "LWMO")
+    if ((*it).tokens[0] == "LWMO") {
         motion_file = true;
+    }
 
-    if ((*it).tokens[0] != "LWSC" && !motion_file)
+    if ((*it).tokens[0] != "LWSC" && !motion_file) {
         throw DeadlyImportError("LWS: Not a LightWave scene, magic tag LWSC not found");
+    }
 
     // get file format version and print to log
     ++it;
@@ -540,31 +541,26 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
     ASSIMP_LOG_INFO("LWS file format version is " + (*it).tokens[0]);
     first = 0.;
     last = 60.;
-    fps = 25.; /* seems to be a good default frame rate */
+    fps = 25.; // seems to be a good default frame rate
 
-    // Now read all elements in a very straghtforward manner
+    // Now read all elements in a very straightforward manner
     for (; it != root.children.end(); ++it) {
         const char *c = (*it).tokens[1].c_str();
 
         // 'FirstFrame': begin of animation slice
         if ((*it).tokens[0] == "FirstFrame") {
-            if (150392. != first /* see SetupProperties() */)
-                first = strtoul10(c, &c) - 1.; /* we're zero-based */
-        }
-
-        // 'LastFrame': end of animation slice
-        else if ((*it).tokens[0] == "LastFrame") {
-            if (150392. != last /* see SetupProperties() */)
-                last = strtoul10(c, &c) - 1.; /* we're zero-based */
-        }
-
-        // 'FramesPerSecond': frames per second
-        else if ((*it).tokens[0] == "FramesPerSecond") {
+            // see SetupProperties()
+            if (150392. != first ) {
+                first = strtoul10(c, &c) - 1.; // we're zero-based
+            }
+        } else if ((*it).tokens[0] == "LastFrame") { // 'LastFrame': end of animation slice
+            // see SetupProperties()
+            if (150392. != last ) {
+                last = strtoul10(c, &c) - 1.; // we're zero-based
+            }
+        } else if ((*it).tokens[0] == "FramesPerSecond") { // 'FramesPerSecond': frames per second
             fps = strtoul10(c, &c);
-        }
-
-        // 'LoadObjectLayer': load a layer of a specific LWO file
-        else if ((*it).tokens[0] == "LoadObjectLayer") {
+        } else if ((*it).tokens[0] == "LoadObjectLayer") { // 'LoadObjectLayer': load a layer of a specific LWO file
 
             // get layer index
             const int layer = strtoul10(c, &c);
@@ -579,8 +575,9 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
             if (version >= 4) { // handle LWSC 4 explicit ID
                 SkipSpaces(&c);
                 d.number = strtoul16(c, &c) & AI_LWS_MASK;
-            } else
+            } else {
                 d.number = cur_object++;
+            }
 
             // and add the file to the import list
             SkipSpaces(&c);
@@ -589,10 +586,8 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
             d.id = batch.AddLoadRequest(path, 0, &props);
 
             nodes.push_back(d);
-            num_object++;
-        }
-        // 'LoadObject': load a LWO file into the scenegraph
-        else if ((*it).tokens[0] == "LoadObject") {
+            ++num_object;
+        } else if ((*it).tokens[0] == "LoadObject") { // 'LoadObject': load a LWO file into the scene-graph
 
             // add node to list
             LWS::NodeDesc d;
@@ -601,17 +596,16 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
             if (version >= 4) { // handle LWSC 4 explicit ID
                 d.number = strtoul16(c, &c) & AI_LWS_MASK;
                 SkipSpaces(&c);
-            } else
+            } else {
                 d.number = cur_object++;
+            }
             std::string path = FindLWOFile(c);
             d.id = batch.AddLoadRequest(path, 0, NULL);
 
             d.path = path;
             nodes.push_back(d);
-            num_object++;
-        }
-        // 'AddNullObject': add a dummy node to the hierarchy
-        else if ((*it).tokens[0] == "AddNullObject") {
+            ++num_object;
+        } else if ((*it).tokens[0] == "AddNullObject") { // 'AddNullObject': add a dummy node to the hierarchy
 
             // add node to list
             LWS::NodeDesc d;
@@ -619,8 +613,9 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
             if (version >= 4) { // handle LWSC 4 explicit ID
                 d.number = strtoul16(c, &c) & AI_LWS_MASK;
                 SkipSpaces(&c);
-            } else
+            } else {
                 d.number = cur_object++;
+            }
             d.name = c;
             nodes.push_back(d);
 
@@ -775,7 +770,6 @@ void LWSImporter::InternReadFile(const std::string &pFile, aiScene *pScene,
         else if ((*it).tokens[0] == "LightFalloffType") {
             if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
                 ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightFalloffType\'");
-
             else
                 nodes.back().lightFalloffType = strtoul10(c);
 
diff --git a/code/LWS/LWSLoader.h b/code/AssetLib/LWS/LWSLoader.h
similarity index 73%
rename from code/LWS/LWSLoader.h
rename to code/AssetLib/LWS/LWSLoader.h
index c1321af37..cc181fa43 100644
--- a/code/LWS/LWSLoader.h
+++ b/code/AssetLib/LWS/LWSLoader.h
@@ -4,7 +4,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -46,19 +45,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_LWSLOADER_H_INCLUDED
 #define AI_LWSLOADER_H_INCLUDED
 
-#include "LWO/LWOFileData.h"
+#include "AssetLib/LWO/LWOFileData.h"
 
-#include <assimp/SceneCombiner.h>
 #include <assimp/BaseImporter.h>
+#include <assimp/SceneCombiner.h>
 
 struct aiImporterDesc;
 
-namespace Assimp    {
-    class BatchLoader;
-    class Importer;
-    class IOSystem;
+namespace Assimp {
+class BatchLoader;
+class Importer;
+class IOSystem;
 
-    namespace LWS   {
+namespace LWS {
 
 // ---------------------------------------------------------------------------
 /** Represents an element in a LWS file.
@@ -66,18 +65,16 @@ namespace Assimp    {
  *  This can either be a single data line - <name> <value> or a data
  *  group - { name <data_line0> ... n }
  */
-class Element
-{
+class Element {
 public:
-    Element()
-    {}
+    Element() {}
 
     // first: name, second: rest
     std::string tokens[2];
     std::list<Element> children;
 
     //! Recursive parsing function
-    void Parse (const char*& buffer);
+    void Parse(const char *&buffer);
 };
 
 #define AI_LWS_MASK (0xffffffff >> 4u)
@@ -85,30 +82,16 @@ public:
 // ---------------------------------------------------------------------------
 /** Represents a LWS scenegraph element
  */
-struct NodeDesc
-{
-    NodeDesc()
-        :   type()
-        ,   id()
-        ,   number  (0)
-        ,   parent  (0)
-        ,   name    ("")
-        ,   isPivotSet (false)
-        ,   lightColor (1.f,1.f,1.f)
-        ,   lightIntensity (1.f)
-        ,   lightType (0)
-        ,   lightFalloffType (0)
-        ,   lightConeAngle (45.f)
-        ,   lightEdgeAngle()
-        ,   parent_resolved (NULL)
-    {}
+struct NodeDesc {
+    NodeDesc() :
+            type(), id(), number(0), parent(0), name(""), isPivotSet(false), lightColor(1.f, 1.f, 1.f), lightIntensity(1.f), lightType(0), lightFalloffType(0), lightConeAngle(45.f), lightEdgeAngle(), parent_resolved(NULL) {}
 
     enum {
 
         OBJECT = 1,
-        LIGHT  = 2,
+        LIGHT = 2,
         CAMERA = 3,
-        BONE   = 4
+        BONE = 4
     } type; // type of node
 
     // if object: path
@@ -122,17 +105,15 @@ struct NodeDesc
     unsigned int parent;
 
     // lights & cameras & dummies: name
-    const char* name;
+    const char *name;
 
     // animation channels
-    std::list< LWO::Envelope > channels;
+    std::list<LWO::Envelope> channels;
 
     // position of pivot point
     aiVector3D pivotPos;
     bool isPivotSet;
 
-
-
     // color of light source
     aiColor3D lightColor;
 
@@ -151,17 +132,14 @@ struct NodeDesc
     // soft cone angle of (spot) light source
     float lightEdgeAngle;
 
-
-
     // list of resolved children
-    std::list< NodeDesc* > children;
+    std::list<NodeDesc *> children;
 
     // resolved parent node
-    NodeDesc* parent_resolved;
-
+    NodeDesc *parent_resolved;
 
     // for std::find()
-    bool operator == (unsigned int num)  const {
+    bool operator==(unsigned int num) const {
         if (!num)
             return false;
         unsigned int _type = num >> 28u;
@@ -179,73 +157,65 @@ struct NodeDesc
  *  contain mainly descriptions how LWO objects are composed together
  *  in a scene.
 */
-class LWSImporter : public BaseImporter
-{
+class LWSImporter : public BaseImporter {
 public:
     LWSImporter();
     ~LWSImporter();
 
-
-public:
-
     // -------------------------------------------------------------------
     // Check whether we can read a specific file
-    bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
-        bool checkSig) const;
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
+            bool checkSig) const;
 
 protected:
-
     // -------------------------------------------------------------------
     // Get list of supported extensions
-    const aiImporterDesc* GetInfo () const;
+    const aiImporterDesc *GetInfo() const;
 
     // -------------------------------------------------------------------
     // Import file into given scene data structure
-    void InternReadFile( const std::string& pFile, aiScene* pScene,
-        IOSystem* pIOHandler);
+    void InternReadFile(const std::string &pFile, aiScene *pScene,
+            IOSystem *pIOHandler);
 
     // -------------------------------------------------------------------
     // Setup import properties
-    void SetupProperties(const Importer* pImp);
+    void SetupProperties(const Importer *pImp);
 
 private:
-
-
     // -------------------------------------------------------------------
     // Read an envelope description
-    void ReadEnvelope(const LWS::Element& dad, LWO::Envelope& out );
+    void ReadEnvelope(const LWS::Element &dad, LWO::Envelope &out);
 
     // -------------------------------------------------------------------
     // Read an envelope description for the older LW file format
-    void ReadEnvelope_Old(std::list< LWS::Element >::const_iterator& it,
-        const std::list< LWS::Element >::const_iterator& end,
-        LWS::NodeDesc& nodes,
-        unsigned int version);
+    void ReadEnvelope_Old(std::list<LWS::Element>::const_iterator &it,
+            const std::list<LWS::Element>::const_iterator &end,
+            LWS::NodeDesc &nodes,
+            unsigned int version);
 
     // -------------------------------------------------------------------
     // Setup a nice name for a node
-    void SetupNodeName(aiNode* nd, LWS::NodeDesc& src);
+    void SetupNodeName(aiNode *nd, LWS::NodeDesc &src);
 
     // -------------------------------------------------------------------
     // Recursively build the scenegraph
-    void BuildGraph(aiNode* nd,
-        LWS::NodeDesc& src,
-        std::vector<AttachmentInfo>& attach,
-        BatchLoader& batch,
-        aiCamera**& camOut,
-        aiLight**& lightOut,
-        std::vector<aiNodeAnim*>& animOut);
+    void BuildGraph(aiNode *nd,
+            LWS::NodeDesc &src,
+            std::vector<AttachmentInfo> &attach,
+            BatchLoader &batch,
+            aiCamera **&camOut,
+            aiLight **&lightOut,
+            std::vector<aiNodeAnim *> &animOut);
 
     // -------------------------------------------------------------------
     // Try several dirs until we find the right location of a LWS file.
-    std::string FindLWOFile(const std::string& in);
+    std::string FindLWOFile(const std::string &in);
 
 private:
-
     bool configSpeedFlag;
-    IOSystem* io;
+    IOSystem *io;
 
-    double first,last,fps;
+    double first, last, fps;
 
     bool noSkeletonMesh;
 };
diff --git a/code/M3D/M3DExporter.cpp b/code/AssetLib/M3D/M3DExporter.cpp
similarity index 100%
rename from code/M3D/M3DExporter.cpp
rename to code/AssetLib/M3D/M3DExporter.cpp
diff --git a/code/M3D/M3DExporter.h b/code/AssetLib/M3D/M3DExporter.h
similarity index 100%
rename from code/M3D/M3DExporter.h
rename to code/AssetLib/M3D/M3DExporter.h
diff --git a/code/M3D/M3DImporter.cpp b/code/AssetLib/M3D/M3DImporter.cpp
similarity index 100%
rename from code/M3D/M3DImporter.cpp
rename to code/AssetLib/M3D/M3DImporter.cpp
diff --git a/code/M3D/M3DImporter.h b/code/AssetLib/M3D/M3DImporter.h
similarity index 100%
rename from code/M3D/M3DImporter.h
rename to code/AssetLib/M3D/M3DImporter.h
diff --git a/code/M3D/M3DMaterials.h b/code/AssetLib/M3D/M3DMaterials.h
similarity index 100%
rename from code/M3D/M3DMaterials.h
rename to code/AssetLib/M3D/M3DMaterials.h
diff --git a/code/M3D/M3DWrapper.cpp b/code/AssetLib/M3D/M3DWrapper.cpp
similarity index 100%
rename from code/M3D/M3DWrapper.cpp
rename to code/AssetLib/M3D/M3DWrapper.cpp
diff --git a/code/M3D/M3DWrapper.h b/code/AssetLib/M3D/M3DWrapper.h
similarity index 100%
rename from code/M3D/M3DWrapper.h
rename to code/AssetLib/M3D/M3DWrapper.h
diff --git a/code/M3D/m3d.h b/code/AssetLib/M3D/m3d.h
similarity index 100%
rename from code/M3D/m3d.h
rename to code/AssetLib/M3D/m3d.h
diff --git a/code/MD2/MD2FileData.h b/code/AssetLib/MD2/MD2FileData.h
similarity index 100%
rename from code/MD2/MD2FileData.h
rename to code/AssetLib/MD2/MD2FileData.h
diff --git a/code/MD2/MD2Loader.cpp b/code/AssetLib/MD2/MD2Loader.cpp
similarity index 100%
rename from code/MD2/MD2Loader.cpp
rename to code/AssetLib/MD2/MD2Loader.cpp
diff --git a/code/MD2/MD2Loader.h b/code/AssetLib/MD2/MD2Loader.h
similarity index 100%
rename from code/MD2/MD2Loader.h
rename to code/AssetLib/MD2/MD2Loader.h
diff --git a/code/MD2/MD2NormalTable.h b/code/AssetLib/MD2/MD2NormalTable.h
similarity index 100%
rename from code/MD2/MD2NormalTable.h
rename to code/AssetLib/MD2/MD2NormalTable.h
diff --git a/code/MD3/MD3FileData.h b/code/AssetLib/MD3/MD3FileData.h
similarity index 100%
rename from code/MD3/MD3FileData.h
rename to code/AssetLib/MD3/MD3FileData.h
diff --git a/code/MD3/MD3Loader.cpp b/code/AssetLib/MD3/MD3Loader.cpp
similarity index 99%
rename from code/MD3/MD3Loader.cpp
rename to code/AssetLib/MD3/MD3Loader.cpp
index 2051ecdda..30be0276e 100644
--- a/code/MD3/MD3Loader.cpp
+++ b/code/AssetLib/MD3/MD3Loader.cpp
@@ -53,7 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
 
-#include "MD3/MD3Loader.h"
+#include "AssetLib/MD3/MD3Loader.h"
 #include "Common/Importer.h"
 
 #include <assimp/SceneCombiner.h>
diff --git a/code/MD3/MD3Loader.h b/code/AssetLib/MD3/MD3Loader.h
similarity index 100%
rename from code/MD3/MD3Loader.h
rename to code/AssetLib/MD3/MD3Loader.h
diff --git a/code/MD4/MD4FileData.h b/code/AssetLib/MD4/MD4FileData.h
similarity index 100%
rename from code/MD4/MD4FileData.h
rename to code/AssetLib/MD4/MD4FileData.h
diff --git a/code/MD5/MD5Loader.cpp b/code/AssetLib/MD5/MD5Loader.cpp
similarity index 100%
rename from code/MD5/MD5Loader.cpp
rename to code/AssetLib/MD5/MD5Loader.cpp
diff --git a/code/MD5/MD5Loader.h b/code/AssetLib/MD5/MD5Loader.h
similarity index 100%
rename from code/MD5/MD5Loader.h
rename to code/AssetLib/MD5/MD5Loader.h
diff --git a/code/MD5/MD5Parser.cpp b/code/AssetLib/MD5/MD5Parser.cpp
similarity index 99%
rename from code/MD5/MD5Parser.cpp
rename to code/AssetLib/MD5/MD5Parser.cpp
index 0d3b9c74a..e2f697816 100644
--- a/code/MD5/MD5Parser.cpp
+++ b/code/AssetLib/MD5/MD5Parser.cpp
@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 // internal headers
-#include "MD5/MD5Loader.h"
+#include "AssetLib/MD5/MD5Loader.h"
 #include "Material/MaterialSystem.h"
 
 #include <assimp/fast_atof.h>
diff --git a/code/MD5/MD5Parser.h b/code/AssetLib/MD5/MD5Parser.h
similarity index 100%
rename from code/MD5/MD5Parser.h
rename to code/AssetLib/MD5/MD5Parser.h
diff --git a/code/MDC/MDCFileData.h b/code/AssetLib/MDC/MDCFileData.h
similarity index 100%
rename from code/MDC/MDCFileData.h
rename to code/AssetLib/MDC/MDCFileData.h
diff --git a/code/MDC/MDCLoader.cpp b/code/AssetLib/MDC/MDCLoader.cpp
similarity index 99%
rename from code/MDC/MDCLoader.cpp
rename to code/AssetLib/MDC/MDCLoader.cpp
index f9b4a3912..60146de81 100644
--- a/code/MDC/MDCLoader.cpp
+++ b/code/AssetLib/MDC/MDCLoader.cpp
@@ -44,9 +44,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_MDC_IMPORTER
 
 // internal headers
-#include "MDC/MDCLoader.h"
-#include "MD3/MD3FileData.h"
-#include "MDC/MDCNormalTable.h" // shouldn't be included by other units
+#include "AssetLib/MDC/MDCLoader.h"
+#include "AssetLib/MD3/MD3FileData.h"
+#include "AssetLib/MDC/MDCNormalTable.h" // shouldn't be included by other units
 
 #include <assimp/importerdesc.h>
 #include <assimp/scene.h>
diff --git a/code/MDC/MDCLoader.h b/code/AssetLib/MDC/MDCLoader.h
similarity index 100%
rename from code/MDC/MDCLoader.h
rename to code/AssetLib/MDC/MDCLoader.h
diff --git a/code/MDC/MDCNormalTable.h b/code/AssetLib/MDC/MDCNormalTable.h
similarity index 100%
rename from code/MDC/MDCNormalTable.h
rename to code/AssetLib/MDC/MDCNormalTable.h
diff --git a/code/MDL/HalfLife/HL1FileData.h b/code/AssetLib/MDL/HalfLife/HL1FileData.h
similarity index 100%
rename from code/MDL/HalfLife/HL1FileData.h
rename to code/AssetLib/MDL/HalfLife/HL1FileData.h
diff --git a/code/MDL/HalfLife/HL1ImportDefinitions.h b/code/AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
similarity index 100%
rename from code/MDL/HalfLife/HL1ImportDefinitions.h
rename to code/AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
diff --git a/code/MDL/HalfLife/HL1ImportSettings.h b/code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
similarity index 100%
rename from code/MDL/HalfLife/HL1ImportSettings.h
rename to code/AssetLib/MDL/HalfLife/HL1ImportSettings.h
diff --git a/code/MDL/HalfLife/HL1MDLLoader.cpp b/code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
similarity index 100%
rename from code/MDL/HalfLife/HL1MDLLoader.cpp
rename to code/AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
diff --git a/code/MDL/HalfLife/HL1MDLLoader.h b/code/AssetLib/MDL/HalfLife/HL1MDLLoader.h
similarity index 100%
rename from code/MDL/HalfLife/HL1MDLLoader.h
rename to code/AssetLib/MDL/HalfLife/HL1MDLLoader.h
diff --git a/code/MDL/HalfLife/HL1MeshTrivert.h b/code/AssetLib/MDL/HalfLife/HL1MeshTrivert.h
similarity index 100%
rename from code/MDL/HalfLife/HL1MeshTrivert.h
rename to code/AssetLib/MDL/HalfLife/HL1MeshTrivert.h
diff --git a/code/MDL/HalfLife/HalfLifeMDLBaseHeader.h b/code/AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
similarity index 100%
rename from code/MDL/HalfLife/HalfLifeMDLBaseHeader.h
rename to code/AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
diff --git a/code/MDL/HalfLife/LogFunctions.h b/code/AssetLib/MDL/HalfLife/LogFunctions.h
similarity index 100%
rename from code/MDL/HalfLife/LogFunctions.h
rename to code/AssetLib/MDL/HalfLife/LogFunctions.h
diff --git a/code/MDL/HalfLife/UniqueNameGenerator.cpp b/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
similarity index 100%
rename from code/MDL/HalfLife/UniqueNameGenerator.cpp
rename to code/AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
diff --git a/code/MDL/HalfLife/UniqueNameGenerator.h b/code/AssetLib/MDL/HalfLife/UniqueNameGenerator.h
similarity index 100%
rename from code/MDL/HalfLife/UniqueNameGenerator.h
rename to code/AssetLib/MDL/HalfLife/UniqueNameGenerator.h
diff --git a/code/MDL/MDLDefaultColorMap.h b/code/AssetLib/MDL/MDLDefaultColorMap.h
similarity index 100%
rename from code/MDL/MDLDefaultColorMap.h
rename to code/AssetLib/MDL/MDLDefaultColorMap.h
diff --git a/code/MDL/MDLFileData.h b/code/AssetLib/MDL/MDLFileData.h
similarity index 100%
rename from code/MDL/MDLFileData.h
rename to code/AssetLib/MDL/MDLFileData.h
diff --git a/code/MDL/MDLLoader.cpp b/code/AssetLib/MDL/MDLLoader.cpp
similarity index 99%
rename from code/MDL/MDLLoader.cpp
rename to code/AssetLib/MDL/MDLLoader.cpp
index 4128b4bfe..463be1f1b 100644
--- a/code/MDL/MDLLoader.cpp
+++ b/code/AssetLib/MDL/MDLLoader.cpp
@@ -48,10 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
 
-#include "MDL/MDLLoader.h"
-#include "MD2/MD2FileData.h"
-#include "MDL/HalfLife/HL1MDLLoader.h"
-#include "MDL/MDLDefaultColorMap.h"
+#include "AssetLib/MDL/MDLLoader.h"
+#include "AssetLib/MD2/MD2FileData.h"
+#include "AssetLib/MDL/HalfLife/HL1MDLLoader.h"
+#include "AssetLib/MDL/MDLDefaultColorMap.h"
 
 #include <assimp/StringUtils.h>
 #include <assimp/importerdesc.h>
diff --git a/code/MDL/MDLLoader.h b/code/AssetLib/MDL/MDLLoader.h
similarity index 99%
rename from code/MDL/MDLLoader.h
rename to code/AssetLib/MDL/MDLLoader.h
index 635b84316..c747559c8 100644
--- a/code/MDL/MDLLoader.h
+++ b/code/AssetLib/MDL/MDLLoader.h
@@ -49,8 +49,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/BaseImporter.h>
 #include "MDLFileData.h"
-#include "HMP/HalfLifeFileData.h"
-#include "HalfLife/HL1ImportSettings.h"
+#include "AssetLib/HMP/HalfLifeFileData.h"
+#include "AssetLib/MDL/HalfLife/HL1ImportSettings.h"
 
 struct aiNode;
 struct aiTexture;
diff --git a/code/MDL/MDLMaterialLoader.cpp b/code/AssetLib/MDL/MDLMaterialLoader.cpp
similarity index 100%
rename from code/MDL/MDLMaterialLoader.cpp
rename to code/AssetLib/MDL/MDLMaterialLoader.cpp
diff --git a/code/MMD/MMDCpp14.h b/code/AssetLib/MMD/MMDCpp14.h
similarity index 100%
rename from code/MMD/MMDCpp14.h
rename to code/AssetLib/MMD/MMDCpp14.h
diff --git a/code/AssetLib/MMD/MMDImporter.cpp b/code/AssetLib/MMD/MMDImporter.cpp
new file mode 100644
index 000000000..7c382bd09
--- /dev/null
+++ b/code/AssetLib/MMD/MMDImporter.cpp
@@ -0,0 +1,373 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+  copyright notice, this list of conditions and the
+  following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the
+  following disclaimer in the documentation and/or other
+  materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+  contributors may be used to endorse or promote products
+  derived from this software without specific prior
+  written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
+
+#include "AssetLib/MMD/MMDImporter.h"
+#include "AssetLib/MMD/MMDPmdParser.h"
+#include "AssetLib/MMD/MMDPmxParser.h"
+#include "AssetLib/MMD/MMDVmdParser.h"
+#include "PostProcessing/ConvertToLHProcess.h"
+
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/ai_assert.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+#include <fstream>
+#include <iomanip>
+#include <memory>
+
+static const aiImporterDesc desc = { "MMD Importer",
+    "",
+    "",
+    "surfaces supported?",
+    aiImporterFlags_SupportTextFlavour,
+    0,
+    0,
+    0,
+    0,
+    "pmx" };
+
+namespace Assimp {
+
+using namespace std;
+
+// ------------------------------------------------------------------------------------------------
+//  Default constructor
+MMDImporter::MMDImporter() :
+        m_Buffer(),
+        m_strAbsPath("") {
+    DefaultIOSystem io;
+    m_strAbsPath = io.getOsSeparator();
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Destructor.
+MMDImporter::~MMDImporter() {
+    // empty
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if file is an pmx file.
+bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
+        bool checkSig) const {
+    if (!checkSig) {
+        return SimpleExtensionCheck(pFile, "pmx");
+    } else {
+        // Check file Header
+        static const char *pTokens[] = { "PMX " };
+        return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 1);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+const aiImporterDesc *MMDImporter::GetInfo() const {
+    return &desc;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  MMD import implementation
+void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene,
+        IOSystem * /*pIOHandler*/) {
+    // Read file by istream
+    std::filebuf fb;
+    if (!fb.open(file, std::ios::in | std::ios::binary)) {
+        throw DeadlyImportError("Failed to open file " + file + ".");
+    }
+
+    std::istream fileStream(&fb);
+
+    // Get the file-size and validate it, throwing an exception when fails
+    fileStream.seekg(0, fileStream.end);
+    size_t fileSize = static_cast<size_t>(fileStream.tellg());
+    fileStream.seekg(0, fileStream.beg);
+
+    if (fileSize < sizeof(pmx::PmxModel)) {
+        throw DeadlyImportError(file + " is too small.");
+    }
+
+    pmx::PmxModel model;
+    model.Read(&fileStream);
+
+    CreateDataFromImport(&model, pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+void MMDImporter::CreateDataFromImport(const pmx::PmxModel *pModel,
+        aiScene *pScene) {
+    if (pModel == NULL) {
+        return;
+    }
+
+    aiNode *pNode = new aiNode;
+    if (!pModel->model_name.empty()) {
+        pNode->mName.Set(pModel->model_name);
+    }
+
+    pScene->mRootNode = pNode;
+
+    pNode = new aiNode;
+    pScene->mRootNode->addChildren(1, &pNode);
+    pNode->mName.Set(string(pModel->model_name) + string("_mesh"));
+
+    // split mesh by materials
+    pNode->mNumMeshes = pModel->material_count;
+    pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
+    for (unsigned int index = 0; index < pNode->mNumMeshes; index++) {
+        pNode->mMeshes[index] = index;
+    }
+
+    pScene->mNumMeshes = pModel->material_count;
+    pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
+    for (unsigned int i = 0, indexStart = 0; i < pScene->mNumMeshes; i++) {
+        const int indexCount = pModel->materials[i].index_count;
+
+        pScene->mMeshes[i] = CreateMesh(pModel, indexStart, indexCount);
+        pScene->mMeshes[i]->mName = pModel->materials[i].material_name;
+        pScene->mMeshes[i]->mMaterialIndex = i;
+        indexStart += indexCount;
+    }
+
+    // create node hierarchy for bone position
+    std::unique_ptr<aiNode *[]> ppNode(new aiNode *[pModel->bone_count]);
+    for (auto i = 0; i < pModel->bone_count; i++) {
+        ppNode[i] = new aiNode(pModel->bones[i].bone_name);
+    }
+
+    for (auto i = 0; i < pModel->bone_count; i++) {
+        const pmx::PmxBone &bone = pModel->bones[i];
+
+        if (bone.parent_index < 0) {
+            pScene->mRootNode->addChildren(1, ppNode.get() + i);
+        } else {
+            ppNode[bone.parent_index]->addChildren(1, ppNode.get() + i);
+
+            aiVector3D v3 = aiVector3D(
+                    bone.position[0] - pModel->bones[bone.parent_index].position[0],
+                    bone.position[1] - pModel->bones[bone.parent_index].position[1],
+                    bone.position[2] - pModel->bones[bone.parent_index].position[2]);
+            aiMatrix4x4::Translation(v3, ppNode[i]->mTransformation);
+        }
+    }
+
+    // create materials
+    pScene->mNumMaterials = pModel->material_count;
+    pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
+    for (unsigned int i = 0; i < pScene->mNumMaterials; i++) {
+        pScene->mMaterials[i] = CreateMaterial(&pModel->materials[i], pModel);
+    }
+
+    // Convert everything to OpenGL space
+    MakeLeftHandedProcess convertProcess;
+    convertProcess.Execute(pScene);
+
+    FlipUVsProcess uvFlipper;
+    uvFlipper.Execute(pScene);
+
+    FlipWindingOrderProcess windingFlipper;
+    windingFlipper.Execute(pScene);
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMesh *MMDImporter::CreateMesh(const pmx::PmxModel *pModel,
+        const int indexStart, const int indexCount) {
+    aiMesh *pMesh = new aiMesh;
+
+    pMesh->mNumVertices = indexCount;
+
+    pMesh->mNumFaces = indexCount / 3;
+    pMesh->mFaces = new aiFace[pMesh->mNumFaces];
+
+    const int numIndices = 3; // triangular face
+    for (unsigned int index = 0; index < pMesh->mNumFaces; index++) {
+        pMesh->mFaces[index].mNumIndices = numIndices;
+        unsigned int *indices = new unsigned int[numIndices];
+        indices[0] = numIndices * index;
+        indices[1] = numIndices * index + 1;
+        indices[2] = numIndices * index + 2;
+        pMesh->mFaces[index].mIndices = indices;
+    }
+
+    pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
+    pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
+    pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
+    pMesh->mNumUVComponents[0] = 2;
+
+    // additional UVs
+    for (int i = 1; i <= pModel->setting.uv; i++) {
+        pMesh->mTextureCoords[i] = new aiVector3D[pMesh->mNumVertices];
+        pMesh->mNumUVComponents[i] = 4;
+    }
+
+    map<int, vector<aiVertexWeight>> bone_vertex_map;
+
+    // fill in contents and create bones
+    for (int index = 0; index < indexCount; index++) {
+        const pmx::PmxVertex *v =
+                &pModel->vertices[pModel->indices[indexStart + index]];
+        const float *position = v->position;
+        pMesh->mVertices[index].Set(position[0], position[1], position[2]);
+        const float *normal = v->normal;
+
+        pMesh->mNormals[index].Set(normal[0], normal[1], normal[2]);
+        pMesh->mTextureCoords[0][index].x = v->uv[0];
+        pMesh->mTextureCoords[0][index].y = v->uv[1];
+
+        for (int i = 1; i <= pModel->setting.uv; i++) {
+            // TODO: wrong here? use quaternion transform?
+            pMesh->mTextureCoords[i][index].x = v->uva[i][0];
+            pMesh->mTextureCoords[i][index].y = v->uva[i][1];
+        }
+
+        // handle bone map
+        const auto vsBDEF1_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningBDEF1 *>(v->skinning.get());
+        const auto vsBDEF2_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningBDEF2 *>(v->skinning.get());
+        const auto vsBDEF4_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningBDEF4 *>(v->skinning.get());
+        const auto vsSDEF_ptr =
+                dynamic_cast<pmx::PmxVertexSkinningSDEF *>(v->skinning.get());
+        switch (v->skinning_type) {
+        case pmx::PmxVertexSkinningType::BDEF1:
+            bone_vertex_map[vsBDEF1_ptr->bone_index].push_back(
+                    aiVertexWeight(index, 1.0));
+            break;
+        case pmx::PmxVertexSkinningType::BDEF2:
+            bone_vertex_map[vsBDEF2_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsBDEF2_ptr->bone_weight));
+            bone_vertex_map[vsBDEF2_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, 1.0f - vsBDEF2_ptr->bone_weight));
+            break;
+        case pmx::PmxVertexSkinningType::BDEF4:
+            bone_vertex_map[vsBDEF4_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight1));
+            bone_vertex_map[vsBDEF4_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight2));
+            bone_vertex_map[vsBDEF4_ptr->bone_index3].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight3));
+            bone_vertex_map[vsBDEF4_ptr->bone_index4].push_back(
+                    aiVertexWeight(index, vsBDEF4_ptr->bone_weight4));
+            break;
+        case pmx::PmxVertexSkinningType::SDEF: // TODO: how to use sdef_c, sdef_r0,
+                // sdef_r1?
+            bone_vertex_map[vsSDEF_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsSDEF_ptr->bone_weight));
+            bone_vertex_map[vsSDEF_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, 1.0f - vsSDEF_ptr->bone_weight));
+            break;
+        case pmx::PmxVertexSkinningType::QDEF:
+            const auto vsQDEF_ptr =
+                    dynamic_cast<pmx::PmxVertexSkinningQDEF *>(v->skinning.get());
+            bone_vertex_map[vsQDEF_ptr->bone_index1].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight1));
+            bone_vertex_map[vsQDEF_ptr->bone_index2].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight2));
+            bone_vertex_map[vsQDEF_ptr->bone_index3].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight3));
+            bone_vertex_map[vsQDEF_ptr->bone_index4].push_back(
+                    aiVertexWeight(index, vsQDEF_ptr->bone_weight4));
+            break;
+        }
+    }
+
+    // make all bones for each mesh
+    // assign bone weights to skinned bones (otherwise just initialize)
+    auto bone_ptr_ptr = new aiBone *[pModel->bone_count];
+    pMesh->mNumBones = pModel->bone_count;
+    pMesh->mBones = bone_ptr_ptr;
+    for (auto ii = 0; ii < pModel->bone_count; ++ii) {
+        auto pBone = new aiBone;
+        const auto &pmxBone = pModel->bones[ii];
+        pBone->mName = pmxBone.bone_name;
+        aiVector3D pos(pmxBone.position[0], pmxBone.position[1], pmxBone.position[2]);
+        aiMatrix4x4::Translation(-pos, pBone->mOffsetMatrix);
+        auto it = bone_vertex_map.find(ii);
+        if (it != bone_vertex_map.end()) {
+            pBone->mNumWeights = static_cast<unsigned int>(it->second.size());
+            pBone->mWeights = new aiVertexWeight[pBone->mNumWeights];
+            for (unsigned int j = 0; j < pBone->mNumWeights; j++) {
+                pBone->mWeights[j] = it->second[j];
+            }
+        }
+        bone_ptr_ptr[ii] = pBone;
+    }
+
+    return pMesh;
+}
+
+// ------------------------------------------------------------------------------------------------
+aiMaterial *MMDImporter::CreateMaterial(const pmx::PmxMaterial *pMat,
+        const pmx::PmxModel *pModel) {
+    aiMaterial *mat = new aiMaterial();
+    aiString name(pMat->material_english_name);
+    mat->AddProperty(&name, AI_MATKEY_NAME);
+
+    aiColor3D diffuse(pMat->diffuse[0], pMat->diffuse[1], pMat->diffuse[2]);
+    mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
+    aiColor3D specular(pMat->specular[0], pMat->specular[1], pMat->specular[2]);
+    mat->AddProperty(&specular, 1, AI_MATKEY_COLOR_SPECULAR);
+    aiColor3D ambient(pMat->ambient[0], pMat->ambient[1], pMat->ambient[2]);
+    mat->AddProperty(&ambient, 1, AI_MATKEY_COLOR_AMBIENT);
+
+    float opacity = pMat->diffuse[3];
+    mat->AddProperty(&opacity, 1, AI_MATKEY_OPACITY);
+    float shininess = pMat->specularlity;
+    mat->AddProperty(&shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
+
+    if (pMat->diffuse_texture_index >= 0) {
+        aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
+        mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
+    }
+
+    int mapping_uvwsrc = 0;
+    mat->AddProperty(&mapping_uvwsrc, 1,
+            AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, 0));
+
+    return mat;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+} // Namespace Assimp
+
+#endif // !! ASSIMP_BUILD_NO_MMD_IMPORTER
diff --git a/code/MMD/MMDImporter.h b/code/AssetLib/MMD/MMDImporter.h
similarity index 100%
rename from code/MMD/MMDImporter.h
rename to code/AssetLib/MMD/MMDImporter.h
diff --git a/code/MMD/MMDPmdParser.h b/code/AssetLib/MMD/MMDPmdParser.h
similarity index 100%
rename from code/MMD/MMDPmdParser.h
rename to code/AssetLib/MMD/MMDPmdParser.h
diff --git a/code/MMD/MMDPmxParser.cpp b/code/AssetLib/MMD/MMDPmxParser.cpp
similarity index 100%
rename from code/MMD/MMDPmxParser.cpp
rename to code/AssetLib/MMD/MMDPmxParser.cpp
diff --git a/code/MMD/MMDPmxParser.h b/code/AssetLib/MMD/MMDPmxParser.h
similarity index 100%
rename from code/MMD/MMDPmxParser.h
rename to code/AssetLib/MMD/MMDPmxParser.h
diff --git a/code/MMD/MMDVmdParser.h b/code/AssetLib/MMD/MMDVmdParser.h
similarity index 100%
rename from code/MMD/MMDVmdParser.h
rename to code/AssetLib/MMD/MMDVmdParser.h
diff --git a/code/MS3D/MS3DLoader.cpp b/code/AssetLib/MS3D/MS3DLoader.cpp
similarity index 100%
rename from code/MS3D/MS3DLoader.cpp
rename to code/AssetLib/MS3D/MS3DLoader.cpp
diff --git a/code/MS3D/MS3DLoader.h b/code/AssetLib/MS3D/MS3DLoader.h
similarity index 100%
rename from code/MS3D/MS3DLoader.h
rename to code/AssetLib/MS3D/MS3DLoader.h
diff --git a/code/NDO/NDOLoader.cpp b/code/AssetLib/NDO/NDOLoader.cpp
similarity index 100%
rename from code/NDO/NDOLoader.cpp
rename to code/AssetLib/NDO/NDOLoader.cpp
diff --git a/code/NDO/NDOLoader.h b/code/AssetLib/NDO/NDOLoader.h
similarity index 100%
rename from code/NDO/NDOLoader.h
rename to code/AssetLib/NDO/NDOLoader.h
diff --git a/code/NFF/NFFLoader.cpp b/code/AssetLib/NFF/NFFLoader.cpp
similarity index 100%
rename from code/NFF/NFFLoader.cpp
rename to code/AssetLib/NFF/NFFLoader.cpp
diff --git a/code/NFF/NFFLoader.h b/code/AssetLib/NFF/NFFLoader.h
similarity index 100%
rename from code/NFF/NFFLoader.h
rename to code/AssetLib/NFF/NFFLoader.h
diff --git a/code/OFF/OFFLoader.cpp b/code/AssetLib/OFF/OFFLoader.cpp
similarity index 100%
rename from code/OFF/OFFLoader.cpp
rename to code/AssetLib/OFF/OFFLoader.cpp
diff --git a/code/OFF/OFFLoader.h b/code/AssetLib/OFF/OFFLoader.h
similarity index 100%
rename from code/OFF/OFFLoader.h
rename to code/AssetLib/OFF/OFFLoader.h
diff --git a/code/Obj/ObjExporter.cpp b/code/AssetLib/Obj/ObjExporter.cpp
similarity index 100%
rename from code/Obj/ObjExporter.cpp
rename to code/AssetLib/Obj/ObjExporter.cpp
diff --git a/code/Obj/ObjExporter.h b/code/AssetLib/Obj/ObjExporter.h
similarity index 100%
rename from code/Obj/ObjExporter.h
rename to code/AssetLib/Obj/ObjExporter.h
diff --git a/code/Obj/ObjFileData.h b/code/AssetLib/Obj/ObjFileData.h
similarity index 100%
rename from code/Obj/ObjFileData.h
rename to code/AssetLib/Obj/ObjFileData.h
diff --git a/code/Obj/ObjFileImporter.cpp b/code/AssetLib/Obj/ObjFileImporter.cpp
similarity index 100%
rename from code/Obj/ObjFileImporter.cpp
rename to code/AssetLib/Obj/ObjFileImporter.cpp
diff --git a/code/Obj/ObjFileImporter.h b/code/AssetLib/Obj/ObjFileImporter.h
similarity index 100%
rename from code/Obj/ObjFileImporter.h
rename to code/AssetLib/Obj/ObjFileImporter.h
diff --git a/code/Obj/ObjFileMtlImporter.cpp b/code/AssetLib/Obj/ObjFileMtlImporter.cpp
similarity index 100%
rename from code/Obj/ObjFileMtlImporter.cpp
rename to code/AssetLib/Obj/ObjFileMtlImporter.cpp
diff --git a/code/Obj/ObjFileMtlImporter.h b/code/AssetLib/Obj/ObjFileMtlImporter.h
similarity index 100%
rename from code/Obj/ObjFileMtlImporter.h
rename to code/AssetLib/Obj/ObjFileMtlImporter.h
diff --git a/code/Obj/ObjFileParser.cpp b/code/AssetLib/Obj/ObjFileParser.cpp
similarity index 100%
rename from code/Obj/ObjFileParser.cpp
rename to code/AssetLib/Obj/ObjFileParser.cpp
diff --git a/code/Obj/ObjFileParser.h b/code/AssetLib/Obj/ObjFileParser.h
similarity index 100%
rename from code/Obj/ObjFileParser.h
rename to code/AssetLib/Obj/ObjFileParser.h
diff --git a/code/Obj/ObjTools.h b/code/AssetLib/Obj/ObjTools.h
similarity index 100%
rename from code/Obj/ObjTools.h
rename to code/AssetLib/Obj/ObjTools.h
diff --git a/code/Ogre/OgreBinarySerializer.cpp b/code/AssetLib/Ogre/OgreBinarySerializer.cpp
similarity index 100%
rename from code/Ogre/OgreBinarySerializer.cpp
rename to code/AssetLib/Ogre/OgreBinarySerializer.cpp
diff --git a/code/Ogre/OgreBinarySerializer.h b/code/AssetLib/Ogre/OgreBinarySerializer.h
similarity index 100%
rename from code/Ogre/OgreBinarySerializer.h
rename to code/AssetLib/Ogre/OgreBinarySerializer.h
diff --git a/code/Ogre/OgreImporter.cpp b/code/AssetLib/Ogre/OgreImporter.cpp
similarity index 100%
rename from code/Ogre/OgreImporter.cpp
rename to code/AssetLib/Ogre/OgreImporter.cpp
diff --git a/code/Ogre/OgreImporter.h b/code/AssetLib/Ogre/OgreImporter.h
similarity index 100%
rename from code/Ogre/OgreImporter.h
rename to code/AssetLib/Ogre/OgreImporter.h
diff --git a/code/Ogre/OgreMaterial.cpp b/code/AssetLib/Ogre/OgreMaterial.cpp
similarity index 100%
rename from code/Ogre/OgreMaterial.cpp
rename to code/AssetLib/Ogre/OgreMaterial.cpp
diff --git a/code/Ogre/OgreParsingUtils.h b/code/AssetLib/Ogre/OgreParsingUtils.h
similarity index 100%
rename from code/Ogre/OgreParsingUtils.h
rename to code/AssetLib/Ogre/OgreParsingUtils.h
diff --git a/code/Ogre/OgreStructs.cpp b/code/AssetLib/Ogre/OgreStructs.cpp
similarity index 100%
rename from code/Ogre/OgreStructs.cpp
rename to code/AssetLib/Ogre/OgreStructs.cpp
diff --git a/code/Ogre/OgreStructs.h b/code/AssetLib/Ogre/OgreStructs.h
similarity index 100%
rename from code/Ogre/OgreStructs.h
rename to code/AssetLib/Ogre/OgreStructs.h
diff --git a/code/Ogre/OgreXmlSerializer.cpp b/code/AssetLib/Ogre/OgreXmlSerializer.cpp
similarity index 100%
rename from code/Ogre/OgreXmlSerializer.cpp
rename to code/AssetLib/Ogre/OgreXmlSerializer.cpp
diff --git a/code/Ogre/OgreXmlSerializer.h b/code/AssetLib/Ogre/OgreXmlSerializer.h
similarity index 100%
rename from code/Ogre/OgreXmlSerializer.h
rename to code/AssetLib/Ogre/OgreXmlSerializer.h
diff --git a/code/OpenGEX/OpenGEXExporter.cpp b/code/AssetLib/OpenGEX/OpenGEXExporter.cpp
similarity index 100%
rename from code/OpenGEX/OpenGEXExporter.cpp
rename to code/AssetLib/OpenGEX/OpenGEXExporter.cpp
diff --git a/code/OpenGEX/OpenGEXExporter.h b/code/AssetLib/OpenGEX/OpenGEXExporter.h
similarity index 100%
rename from code/OpenGEX/OpenGEXExporter.h
rename to code/AssetLib/OpenGEX/OpenGEXExporter.h
diff --git a/code/OpenGEX/OpenGEXImporter.cpp b/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
similarity index 99%
rename from code/OpenGEX/OpenGEXImporter.cpp
rename to code/AssetLib/OpenGEX/OpenGEXImporter.cpp
index bfdf144aa..880303065 100644
--- a/code/OpenGEX/OpenGEXImporter.cpp
+++ b/code/AssetLib/OpenGEX/OpenGEXImporter.cpp
@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
 
-#include "OpenGEX/OpenGEXImporter.h"
+#include "AssetLib/OpenGEX/OpenGEXImporter.h"
 #include "PostProcessing/MakeVerboseFormat.h"
 
 #include <assimp/DefaultIOSystem.h>
diff --git a/code/OpenGEX/OpenGEXImporter.h b/code/AssetLib/OpenGEX/OpenGEXImporter.h
similarity index 100%
rename from code/OpenGEX/OpenGEXImporter.h
rename to code/AssetLib/OpenGEX/OpenGEXImporter.h
diff --git a/code/OpenGEX/OpenGEXStructs.h b/code/AssetLib/OpenGEX/OpenGEXStructs.h
similarity index 100%
rename from code/OpenGEX/OpenGEXStructs.h
rename to code/AssetLib/OpenGEX/OpenGEXStructs.h
diff --git a/code/Ply/PlyExporter.cpp b/code/AssetLib/Ply/PlyExporter.cpp
similarity index 100%
rename from code/Ply/PlyExporter.cpp
rename to code/AssetLib/Ply/PlyExporter.cpp
diff --git a/code/Ply/PlyExporter.h b/code/AssetLib/Ply/PlyExporter.h
similarity index 100%
rename from code/Ply/PlyExporter.h
rename to code/AssetLib/Ply/PlyExporter.h
diff --git a/code/Ply/PlyLoader.cpp b/code/AssetLib/Ply/PlyLoader.cpp
similarity index 100%
rename from code/Ply/PlyLoader.cpp
rename to code/AssetLib/Ply/PlyLoader.cpp
diff --git a/code/Ply/PlyLoader.h b/code/AssetLib/Ply/PlyLoader.h
similarity index 100%
rename from code/Ply/PlyLoader.h
rename to code/AssetLib/Ply/PlyLoader.h
diff --git a/code/Ply/PlyParser.cpp b/code/AssetLib/Ply/PlyParser.cpp
similarity index 100%
rename from code/Ply/PlyParser.cpp
rename to code/AssetLib/Ply/PlyParser.cpp
diff --git a/code/Ply/PlyParser.h b/code/AssetLib/Ply/PlyParser.h
similarity index 100%
rename from code/Ply/PlyParser.h
rename to code/AssetLib/Ply/PlyParser.h
diff --git a/code/Q3BSP/Q3BSPFileData.h b/code/AssetLib/Q3BSP/Q3BSPFileData.h
similarity index 100%
rename from code/Q3BSP/Q3BSPFileData.h
rename to code/AssetLib/Q3BSP/Q3BSPFileData.h
diff --git a/code/Q3BSP/Q3BSPFileImporter.cpp b/code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp
similarity index 100%
rename from code/Q3BSP/Q3BSPFileImporter.cpp
rename to code/AssetLib/Q3BSP/Q3BSPFileImporter.cpp
diff --git a/code/Q3BSP/Q3BSPFileImporter.h b/code/AssetLib/Q3BSP/Q3BSPFileImporter.h
similarity index 100%
rename from code/Q3BSP/Q3BSPFileImporter.h
rename to code/AssetLib/Q3BSP/Q3BSPFileImporter.h
diff --git a/code/Q3BSP/Q3BSPFileParser.cpp b/code/AssetLib/Q3BSP/Q3BSPFileParser.cpp
similarity index 100%
rename from code/Q3BSP/Q3BSPFileParser.cpp
rename to code/AssetLib/Q3BSP/Q3BSPFileParser.cpp
diff --git a/code/Q3BSP/Q3BSPFileParser.h b/code/AssetLib/Q3BSP/Q3BSPFileParser.h
similarity index 100%
rename from code/Q3BSP/Q3BSPFileParser.h
rename to code/AssetLib/Q3BSP/Q3BSPFileParser.h
diff --git a/code/Q3D/Q3DLoader.cpp b/code/AssetLib/Q3D/Q3DLoader.cpp
similarity index 100%
rename from code/Q3D/Q3DLoader.cpp
rename to code/AssetLib/Q3D/Q3DLoader.cpp
diff --git a/code/Q3D/Q3DLoader.h b/code/AssetLib/Q3D/Q3DLoader.h
similarity index 100%
rename from code/Q3D/Q3DLoader.h
rename to code/AssetLib/Q3D/Q3DLoader.h
diff --git a/code/Raw/RawLoader.cpp b/code/AssetLib/Raw/RawLoader.cpp
similarity index 100%
rename from code/Raw/RawLoader.cpp
rename to code/AssetLib/Raw/RawLoader.cpp
diff --git a/code/Raw/RawLoader.h b/code/AssetLib/Raw/RawLoader.h
similarity index 100%
rename from code/Raw/RawLoader.h
rename to code/AssetLib/Raw/RawLoader.h
diff --git a/code/SIB/SIBImporter.cpp b/code/AssetLib/SIB/SIBImporter.cpp
similarity index 100%
rename from code/SIB/SIBImporter.cpp
rename to code/AssetLib/SIB/SIBImporter.cpp
diff --git a/code/SIB/SIBImporter.h b/code/AssetLib/SIB/SIBImporter.h
similarity index 100%
rename from code/SIB/SIBImporter.h
rename to code/AssetLib/SIB/SIBImporter.h
diff --git a/code/SMD/SMDLoader.cpp b/code/AssetLib/SMD/SMDLoader.cpp
similarity index 100%
rename from code/SMD/SMDLoader.cpp
rename to code/AssetLib/SMD/SMDLoader.cpp
diff --git a/code/SMD/SMDLoader.h b/code/AssetLib/SMD/SMDLoader.h
similarity index 100%
rename from code/SMD/SMDLoader.h
rename to code/AssetLib/SMD/SMDLoader.h
diff --git a/code/Importer/STEPParser/STEPFileEncoding.cpp b/code/AssetLib/STEPParser/STEPFileEncoding.cpp
similarity index 100%
rename from code/Importer/STEPParser/STEPFileEncoding.cpp
rename to code/AssetLib/STEPParser/STEPFileEncoding.cpp
diff --git a/code/Importer/STEPParser/STEPFileEncoding.h b/code/AssetLib/STEPParser/STEPFileEncoding.h
similarity index 100%
rename from code/Importer/STEPParser/STEPFileEncoding.h
rename to code/AssetLib/STEPParser/STEPFileEncoding.h
diff --git a/code/Importer/STEPParser/STEPFileReader.cpp b/code/AssetLib/STEPParser/STEPFileReader.cpp
similarity index 100%
rename from code/Importer/STEPParser/STEPFileReader.cpp
rename to code/AssetLib/STEPParser/STEPFileReader.cpp
diff --git a/code/Importer/STEPParser/STEPFileReader.h b/code/AssetLib/STEPParser/STEPFileReader.h
similarity index 98%
rename from code/Importer/STEPParser/STEPFileReader.h
rename to code/AssetLib/STEPParser/STEPFileReader.h
index 62292792a..0fa8c9bb7 100644
--- a/code/Importer/STEPParser/STEPFileReader.h
+++ b/code/AssetLib/STEPParser/STEPFileReader.h
@@ -43,7 +43,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_STEPFILEREADER_H
 #define INCLUDED_AI_STEPFILEREADER_H
 
-#include "code/Step/STEPFile.h"
+#include "AssetLib/Step/STEPFile.h"
 
 namespace Assimp {
 namespace STEP {
diff --git a/code/STL/STLExporter.cpp b/code/AssetLib/STL/STLExporter.cpp
similarity index 100%
rename from code/STL/STLExporter.cpp
rename to code/AssetLib/STL/STLExporter.cpp
diff --git a/code/STL/STLExporter.h b/code/AssetLib/STL/STLExporter.h
similarity index 100%
rename from code/STL/STLExporter.h
rename to code/AssetLib/STL/STLExporter.h
diff --git a/code/STL/STLLoader.cpp b/code/AssetLib/STL/STLLoader.cpp
similarity index 100%
rename from code/STL/STLLoader.cpp
rename to code/AssetLib/STL/STLLoader.cpp
diff --git a/code/STL/STLLoader.h b/code/AssetLib/STL/STLLoader.h
similarity index 100%
rename from code/STL/STLLoader.h
rename to code/AssetLib/STL/STLLoader.h
diff --git a/code/Step/STEPFile.h b/code/AssetLib/Step/STEPFile.h
similarity index 99%
rename from code/Step/STEPFile.h
rename to code/AssetLib/Step/STEPFile.h
index dcfffbeb8..1448c107f 100644
--- a/code/Step/STEPFile.h
+++ b/code/AssetLib/Step/STEPFile.h
@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <typeinfo>
 #include <vector>
 
-#include "FBX/FBXDocument.h" //ObjectMap::value_type
+#include "AssetLib/FBX/FBXDocument.h" //ObjectMap::value_type
 
 #include <assimp/DefaultLogger.hpp>
 
diff --git a/code/Step/StepExporter.cpp b/code/AssetLib/Step/StepExporter.cpp
similarity index 99%
rename from code/Step/StepExporter.cpp
rename to code/AssetLib/Step/StepExporter.cpp
index 56aedb96c..279ecabe9 100644
--- a/code/Step/StepExporter.cpp
+++ b/code/AssetLib/Step/StepExporter.cpp
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_STEP_EXPORTER
 
-#include "Step/StepExporter.h"
+#include "AssetLib/Step/StepExporter.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/Bitmap.h>
diff --git a/code/Step/StepExporter.h b/code/AssetLib/Step/StepExporter.h
similarity index 100%
rename from code/Step/StepExporter.h
rename to code/AssetLib/Step/StepExporter.h
diff --git a/code/Importer/StepFile/StepFileGen1.cpp b/code/AssetLib/StepFile/StepFileGen1.cpp
similarity index 100%
rename from code/Importer/StepFile/StepFileGen1.cpp
rename to code/AssetLib/StepFile/StepFileGen1.cpp
diff --git a/code/Importer/StepFile/StepFileGen2.cpp b/code/AssetLib/StepFile/StepFileGen2.cpp
similarity index 100%
rename from code/Importer/StepFile/StepFileGen2.cpp
rename to code/AssetLib/StepFile/StepFileGen2.cpp
diff --git a/code/Importer/StepFile/StepFileGen3.cpp b/code/AssetLib/StepFile/StepFileGen3.cpp
similarity index 100%
rename from code/Importer/StepFile/StepFileGen3.cpp
rename to code/AssetLib/StepFile/StepFileGen3.cpp
diff --git a/code/Importer/StepFile/StepFileImporter.cpp b/code/AssetLib/StepFile/StepFileImporter.cpp
similarity index 100%
rename from code/Importer/StepFile/StepFileImporter.cpp
rename to code/AssetLib/StepFile/StepFileImporter.cpp
diff --git a/code/Importer/StepFile/StepFileImporter.h b/code/AssetLib/StepFile/StepFileImporter.h
similarity index 100%
rename from code/Importer/StepFile/StepFileImporter.h
rename to code/AssetLib/StepFile/StepFileImporter.h
diff --git a/code/Importer/StepFile/StepReaderGen.h b/code/AssetLib/StepFile/StepReaderGen.h
similarity index 100%
rename from code/Importer/StepFile/StepReaderGen.h
rename to code/AssetLib/StepFile/StepReaderGen.h
diff --git a/code/Terragen/TerragenLoader.cpp b/code/AssetLib/Terragen/TerragenLoader.cpp
similarity index 100%
rename from code/Terragen/TerragenLoader.cpp
rename to code/AssetLib/Terragen/TerragenLoader.cpp
diff --git a/code/Terragen/TerragenLoader.h b/code/AssetLib/Terragen/TerragenLoader.h
similarity index 100%
rename from code/Terragen/TerragenLoader.h
rename to code/AssetLib/Terragen/TerragenLoader.h
diff --git a/code/Unreal/UnrealLoader.cpp b/code/AssetLib/Unreal/UnrealLoader.cpp
similarity index 99%
rename from code/Unreal/UnrealLoader.cpp
rename to code/AssetLib/Unreal/UnrealLoader.cpp
index 275c39b32..9cbfa436b 100644
--- a/code/Unreal/UnrealLoader.cpp
+++ b/code/AssetLib/Unreal/UnrealLoader.cpp
@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
 
-#include "Unreal/UnrealLoader.h"
+#include "AssetLib/Unreal/UnrealLoader.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/ParsingUtils.h>
diff --git a/code/Unreal/UnrealLoader.h b/code/AssetLib/Unreal/UnrealLoader.h
similarity index 100%
rename from code/Unreal/UnrealLoader.h
rename to code/AssetLib/Unreal/UnrealLoader.h
diff --git a/code/X/XFileExporter.cpp b/code/AssetLib/X/XFileExporter.cpp
similarity index 99%
rename from code/X/XFileExporter.cpp
rename to code/AssetLib/X/XFileExporter.cpp
index 5b1c49eab..41b58487e 100644
--- a/code/X/XFileExporter.cpp
+++ b/code/AssetLib/X/XFileExporter.cpp
@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_X_EXPORTER
 
-#include "X/XFileExporter.h"
+#include "AssetLib/X/XFileExporter.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/Bitmap.h>
diff --git a/code/X/XFileExporter.h b/code/AssetLib/X/XFileExporter.h
similarity index 100%
rename from code/X/XFileExporter.h
rename to code/AssetLib/X/XFileExporter.h
diff --git a/code/X/XFileHelper.h b/code/AssetLib/X/XFileHelper.h
similarity index 100%
rename from code/X/XFileHelper.h
rename to code/AssetLib/X/XFileHelper.h
diff --git a/code/X/XFileImporter.cpp b/code/AssetLib/X/XFileImporter.cpp
similarity index 99%
rename from code/X/XFileImporter.cpp
rename to code/AssetLib/X/XFileImporter.cpp
index 846023b93..277948b08 100644
--- a/code/X/XFileImporter.cpp
+++ b/code/AssetLib/X/XFileImporter.cpp
@@ -44,8 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_X_IMPORTER
 
-#include "X/XFileImporter.h"
-#include "X/XFileParser.h"
+#include "AssetLib/X/XFileImporter.h"
+#include "AssetLib/X/XFileParser.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
 #include <assimp/TinyFormatter.h>
diff --git a/code/X/XFileImporter.h b/code/AssetLib/X/XFileImporter.h
similarity index 100%
rename from code/X/XFileImporter.h
rename to code/AssetLib/X/XFileImporter.h
diff --git a/code/X/XFileParser.cpp b/code/AssetLib/X/XFileParser.cpp
similarity index 100%
rename from code/X/XFileParser.cpp
rename to code/AssetLib/X/XFileParser.cpp
diff --git a/code/X/XFileParser.h b/code/AssetLib/X/XFileParser.h
similarity index 100%
rename from code/X/XFileParser.h
rename to code/AssetLib/X/XFileParser.h
diff --git a/code/X3D/FIReader.cpp b/code/AssetLib/X3D/FIReader.cpp
similarity index 100%
rename from code/X3D/FIReader.cpp
rename to code/AssetLib/X3D/FIReader.cpp
diff --git a/code/X3D/FIReader.hpp b/code/AssetLib/X3D/FIReader.hpp
similarity index 100%
rename from code/X3D/FIReader.hpp
rename to code/AssetLib/X3D/FIReader.hpp
diff --git a/code/X3D/X3DExporter.cpp b/code/AssetLib/X3D/X3DExporter.cpp
similarity index 100%
rename from code/X3D/X3DExporter.cpp
rename to code/AssetLib/X3D/X3DExporter.cpp
diff --git a/code/X3D/X3DExporter.hpp b/code/AssetLib/X3D/X3DExporter.hpp
similarity index 100%
rename from code/X3D/X3DExporter.hpp
rename to code/AssetLib/X3D/X3DExporter.hpp
diff --git a/code/X3D/X3DImporter.cpp b/code/AssetLib/X3D/X3DImporter.cpp
similarity index 100%
rename from code/X3D/X3DImporter.cpp
rename to code/AssetLib/X3D/X3DImporter.cpp
diff --git a/code/X3D/X3DImporter.hpp b/code/AssetLib/X3D/X3DImporter.hpp
similarity index 100%
rename from code/X3D/X3DImporter.hpp
rename to code/AssetLib/X3D/X3DImporter.hpp
diff --git a/code/X3D/X3DImporter_Geometry2D.cpp b/code/AssetLib/X3D/X3DImporter_Geometry2D.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Geometry2D.cpp
rename to code/AssetLib/X3D/X3DImporter_Geometry2D.cpp
diff --git a/code/X3D/X3DImporter_Geometry3D.cpp b/code/AssetLib/X3D/X3DImporter_Geometry3D.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Geometry3D.cpp
rename to code/AssetLib/X3D/X3DImporter_Geometry3D.cpp
diff --git a/code/X3D/X3DImporter_Group.cpp b/code/AssetLib/X3D/X3DImporter_Group.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Group.cpp
rename to code/AssetLib/X3D/X3DImporter_Group.cpp
diff --git a/code/X3D/X3DImporter_Light.cpp b/code/AssetLib/X3D/X3DImporter_Light.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Light.cpp
rename to code/AssetLib/X3D/X3DImporter_Light.cpp
diff --git a/code/X3D/X3DImporter_Macro.hpp b/code/AssetLib/X3D/X3DImporter_Macro.hpp
similarity index 100%
rename from code/X3D/X3DImporter_Macro.hpp
rename to code/AssetLib/X3D/X3DImporter_Macro.hpp
diff --git a/code/X3D/X3DImporter_Metadata.cpp b/code/AssetLib/X3D/X3DImporter_Metadata.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Metadata.cpp
rename to code/AssetLib/X3D/X3DImporter_Metadata.cpp
diff --git a/code/X3D/X3DImporter_Networking.cpp b/code/AssetLib/X3D/X3DImporter_Networking.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Networking.cpp
rename to code/AssetLib/X3D/X3DImporter_Networking.cpp
diff --git a/code/X3D/X3DImporter_Node.hpp b/code/AssetLib/X3D/X3DImporter_Node.hpp
similarity index 100%
rename from code/X3D/X3DImporter_Node.hpp
rename to code/AssetLib/X3D/X3DImporter_Node.hpp
diff --git a/code/X3D/X3DImporter_Postprocess.cpp b/code/AssetLib/X3D/X3DImporter_Postprocess.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Postprocess.cpp
rename to code/AssetLib/X3D/X3DImporter_Postprocess.cpp
diff --git a/code/X3D/X3DImporter_Rendering.cpp b/code/AssetLib/X3D/X3DImporter_Rendering.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Rendering.cpp
rename to code/AssetLib/X3D/X3DImporter_Rendering.cpp
diff --git a/code/X3D/X3DImporter_Shape.cpp b/code/AssetLib/X3D/X3DImporter_Shape.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Shape.cpp
rename to code/AssetLib/X3D/X3DImporter_Shape.cpp
diff --git a/code/X3D/X3DImporter_Texturing.cpp b/code/AssetLib/X3D/X3DImporter_Texturing.cpp
similarity index 100%
rename from code/X3D/X3DImporter_Texturing.cpp
rename to code/AssetLib/X3D/X3DImporter_Texturing.cpp
diff --git a/code/X3D/X3DVocabulary.cpp b/code/AssetLib/X3D/X3DVocabulary.cpp
similarity index 100%
rename from code/X3D/X3DVocabulary.cpp
rename to code/AssetLib/X3D/X3DVocabulary.cpp
diff --git a/code/XGL/XGLLoader.cpp b/code/AssetLib/XGL/XGLLoader.cpp
similarity index 100%
rename from code/XGL/XGLLoader.cpp
rename to code/AssetLib/XGL/XGLLoader.cpp
diff --git a/code/XGL/XGLLoader.h b/code/AssetLib/XGL/XGLLoader.h
similarity index 100%
rename from code/XGL/XGLLoader.h
rename to code/AssetLib/XGL/XGLLoader.h
diff --git a/code/glTF/glTFAsset.h b/code/AssetLib/glTF/glTFAsset.h
similarity index 99%
rename from code/glTF/glTFAsset.h
rename to code/AssetLib/glTF/glTFAsset.h
index 9673624f5..f24e35a16 100644
--- a/code/glTF/glTFAsset.h
+++ b/code/AssetLib/glTF/glTFAsset.h
@@ -92,7 +92,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #   endif
 #endif
 
-#include "glTF/glTFCommon.h"
+#include "AssetLib/glTF/glTFCommon.h"
 
 namespace glTF
 {
diff --git a/code/glTF/glTFAsset.inl b/code/AssetLib/glTF/glTFAsset.inl
similarity index 100%
rename from code/glTF/glTFAsset.inl
rename to code/AssetLib/glTF/glTFAsset.inl
diff --git a/code/glTF/glTFAssetWriter.h b/code/AssetLib/glTF/glTFAssetWriter.h
similarity index 100%
rename from code/glTF/glTFAssetWriter.h
rename to code/AssetLib/glTF/glTFAssetWriter.h
diff --git a/code/glTF/glTFAssetWriter.inl b/code/AssetLib/glTF/glTFAssetWriter.inl
similarity index 100%
rename from code/glTF/glTFAssetWriter.inl
rename to code/AssetLib/glTF/glTFAssetWriter.inl
diff --git a/code/glTF/glTFCommon.cpp b/code/AssetLib/glTF/glTFCommon.cpp
similarity index 99%
rename from code/glTF/glTFCommon.cpp
rename to code/AssetLib/glTF/glTFCommon.cpp
index 1c662a16a..e0ce4fed8 100644
--- a/code/glTF/glTFCommon.cpp
+++ b/code/AssetLib/glTF/glTFCommon.cpp
@@ -38,7 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
-#include "glTF/glTFCommon.h"
+#include "AssetLib/glTF/glTFCommon.h"
 
 namespace glTFCommon {
 
diff --git a/code/glTF/glTFCommon.h b/code/AssetLib/glTF/glTFCommon.h
similarity index 100%
rename from code/glTF/glTFCommon.h
rename to code/AssetLib/glTF/glTFCommon.h
diff --git a/code/glTF/glTFExporter.cpp b/code/AssetLib/glTF/glTFExporter.cpp
similarity index 99%
rename from code/glTF/glTFExporter.cpp
rename to code/AssetLib/glTF/glTFExporter.cpp
index 564b1e5bb..57207e8c7 100644
--- a/code/glTF/glTFExporter.cpp
+++ b/code/AssetLib/glTF/glTFExporter.cpp
@@ -42,8 +42,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
 
-#include "glTF/glTFExporter.h"
-#include "glTF/glTFAssetWriter.h"
+#include "AssetLib/glTF/glTFExporter.h"
+#include "AssetLib/glTF/glTFAssetWriter.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
 #include <assimp/commonMetaData.h>
diff --git a/code/glTF/glTFExporter.h b/code/AssetLib/glTF/glTFExporter.h
similarity index 100%
rename from code/glTF/glTFExporter.h
rename to code/AssetLib/glTF/glTFExporter.h
diff --git a/code/glTF/glTFImporter.cpp b/code/AssetLib/glTF/glTFImporter.cpp
similarity index 99%
rename from code/glTF/glTFImporter.cpp
rename to code/AssetLib/glTF/glTFImporter.cpp
index 4799a5f01..32ce8b227 100644
--- a/code/glTF/glTFImporter.cpp
+++ b/code/AssetLib/glTF/glTFImporter.cpp
@@ -41,9 +41,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
 
-#include "glTF/glTFImporter.h"
-#include "glTF/glTFAsset.h"
-#include "glTF/glTFAssetWriter.h"
+#include "AssetLib/glTF/glTFImporter.h"
+#include "AssetLib/glTF/glTFAsset.h"
+#include "AssetLib/glTF/glTFAssetWriter.h"
 #include "PostProcessing/MakeVerboseFormat.h"
 
 #include <assimp/StringComparison.h>
diff --git a/code/glTF/glTFImporter.h b/code/AssetLib/glTF/glTFImporter.h
similarity index 100%
rename from code/glTF/glTFImporter.h
rename to code/AssetLib/glTF/glTFImporter.h
diff --git a/code/glTF2/glTF2Asset.h b/code/AssetLib/glTF2/glTF2Asset.h
similarity index 99%
rename from code/glTF2/glTF2Asset.h
rename to code/AssetLib/glTF2/glTF2Asset.h
index f9add768e..48dab24a7 100644
--- a/code/glTF2/glTF2Asset.h
+++ b/code/AssetLib/glTF2/glTF2Asset.h
@@ -99,9 +99,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/StringUtils.h>
 
-#include "glTF/glTFCommon.h"
+#include "AssetLib/glTF/glTFCommon.h"
 
 namespace glTF2 {
+
 using glTFCommon::IOStream;
 using glTFCommon::IOSystem;
 using glTFCommon::shared_ptr;
diff --git a/code/glTF2/glTF2Asset.inl b/code/AssetLib/glTF2/glTF2Asset.inl
similarity index 99%
rename from code/glTF2/glTF2Asset.inl
rename to code/AssetLib/glTF2/glTF2Asset.inl
index ed23b388a..0c99d059b 100644
--- a/code/glTF2/glTF2Asset.inl
+++ b/code/AssetLib/glTF2/glTF2Asset.inl
@@ -40,10 +40,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-#include "glTF/glTFCommon.h"
-#include <assimp/StringUtils.h>
+#include "AssetLib/glTF/glTFCommon.h"
 
-// Header files, Assimp
+#include <assimp/StringUtils.h>
 #include <assimp/DefaultLogger.hpp>
 
 using namespace Assimp;
diff --git a/code/glTF2/glTF2AssetWriter.h b/code/AssetLib/glTF2/glTF2AssetWriter.h
similarity index 100%
rename from code/glTF2/glTF2AssetWriter.h
rename to code/AssetLib/glTF2/glTF2AssetWriter.h
diff --git a/code/glTF2/glTF2AssetWriter.inl b/code/AssetLib/glTF2/glTF2AssetWriter.inl
similarity index 100%
rename from code/glTF2/glTF2AssetWriter.inl
rename to code/AssetLib/glTF2/glTF2AssetWriter.inl
diff --git a/code/glTF2/glTF2Exporter.cpp b/code/AssetLib/glTF2/glTF2Exporter.cpp
similarity index 99%
rename from code/glTF2/glTF2Exporter.cpp
rename to code/AssetLib/glTF2/glTF2Exporter.cpp
index d101cd77a..a6128b032 100644
--- a/code/glTF2/glTF2Exporter.cpp
+++ b/code/AssetLib/glTF2/glTF2Exporter.cpp
@@ -42,8 +42,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_GLTF_EXPORTER
 
-#include "glTF2/glTF2Exporter.h"
-#include "glTF2/glTF2AssetWriter.h"
+#include "AssetLib/glTF2/glTF2Exporter.h"
+#include "AssetLib/glTF2/glTF2AssetWriter.h"
 #include "PostProcessing/SplitLargeMeshes.h"
 
 #include <assimp/commonMetaData.h>
diff --git a/code/glTF2/glTF2Exporter.h b/code/AssetLib/glTF2/glTF2Exporter.h
similarity index 100%
rename from code/glTF2/glTF2Exporter.h
rename to code/AssetLib/glTF2/glTF2Exporter.h
diff --git a/code/glTF2/glTF2Importer.cpp b/code/AssetLib/glTF2/glTF2Importer.cpp
similarity index 99%
rename from code/glTF2/glTF2Importer.cpp
rename to code/AssetLib/glTF2/glTF2Importer.cpp
index 75fb3d1b7..10d0bc83b 100644
--- a/code/glTF2/glTF2Importer.cpp
+++ b/code/AssetLib/glTF2/glTF2Importer.cpp
@@ -41,10 +41,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
 
-#include "glTF2/glTF2Importer.h"
+#include "AssetLib/glTF2/glTF2Importer.h"
 #include "PostProcessing/MakeVerboseFormat.h"
-#include "glTF2/glTF2Asset.h"
-#include "glTF2/glTF2AssetWriter.h"
+#include "AssetLib/glTF2/glTF2Asset.h"
+#include "AssetLib/glTF2/glTF2AssetWriter.h"
 
 #include <assimp/CreateAnimMesh.h>
 #include <assimp/StringComparison.h>
diff --git a/code/glTF2/glTF2Importer.h b/code/AssetLib/glTF2/glTF2Importer.h
similarity index 100%
rename from code/glTF2/glTF2Importer.h
rename to code/AssetLib/glTF2/glTF2Importer.h
diff --git a/code/Assxml/AssxmlFileWriter.cpp b/code/Assxml/AssxmlFileWriter.cpp
deleted file mode 100644
index 3a88d5052..000000000
--- a/code/Assxml/AssxmlFileWriter.cpp
+++ /dev/null
@@ -1,664 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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 AssxmlFileWriter.cpp
- *  @brief Implementation of Assxml file writer.
- */
-
-#include "AssxmlFileWriter.h"
-
-#include "PostProcessing/ProcessHelper.h"
-
-#include <assimp/version.h>
-#include <assimp/IOStream.hpp>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-
-#include <stdarg.h>
-
-#ifdef ASSIMP_BUILD_NO_OWN_ZLIB
-#   include <zlib.h>
-#else
-#   include <contrib/zlib/zlib.h>
-#endif
-
-#include <time.h>
-#include <stdio.h>
-#include <memory>
-
-using namespace Assimp;
-
-namespace Assimp {
-
-namespace AssxmlFileWriter  {
-
-// -----------------------------------------------------------------------------------
-static int ioprintf( IOStream * io, const char *format, ... ) {
-    using namespace std;
-    if ( nullptr == io ) {
-        return -1;
-    }
-
-    static const int Size = 4096;
-    char sz[ Size ];
-    ::memset( sz, '\0', Size );
-    va_list va;
-    va_start( va, format );
-    const unsigned int nSize = vsnprintf( sz, Size-1, format, va );
-    ai_assert( nSize < Size );
-    va_end( va );
-
-    io->Write( sz, sizeof(char), nSize );
-
-    return nSize;
-}
-
-// -----------------------------------------------------------------------------------
-// Convert a name to standard XML format
-static void ConvertName(aiString& out, const aiString& in) {
-    out.length = 0;
-    for (unsigned int i = 0; i < in.length; ++i)  {
-        switch (in.data[i]) {
-            case '<':
-                out.Append("&lt;");break;
-            case '>':
-                out.Append("&gt;");break;
-            case '&':
-                out.Append("&amp;");break;
-            case '\"':
-                out.Append("&quot;");break;
-            case '\'':
-                out.Append("&apos;");break;
-            default:
-                out.data[out.length++] = in.data[i];
-        }
-    }
-    out.data[out.length] = 0;
-}
-
-// -----------------------------------------------------------------------------------
-// Write a single node as text dump
-static void WriteNode(const aiNode* node, IOStream * io, unsigned int depth) {
-    char prefix[512];
-    for (unsigned int i = 0; i < depth;++i)
-        prefix[i] = '\t';
-    prefix[depth] = '\0';
-
-    const aiMatrix4x4& m = node->mTransformation;
-
-    aiString name;
-    ConvertName(name,node->mName);
-    ioprintf(io,"%s<Node name=\"%s\"> \n"
-        "%s\t<Matrix4> \n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t\t%0 6f %0 6f %0 6f %0 6f\n"
-        "%s\t</Matrix4> \n",
-        prefix,name.data,prefix,
-        prefix,m.a1,m.a2,m.a3,m.a4,
-        prefix,m.b1,m.b2,m.b3,m.b4,
-        prefix,m.c1,m.c2,m.c3,m.c4,
-        prefix,m.d1,m.d2,m.d3,m.d4,prefix);
-
-    if (node->mNumMeshes) {
-        ioprintf(io, "%s\t<MeshRefs num=\"%u\">\n%s\t",
-            prefix,node->mNumMeshes,prefix);
-
-        for (unsigned int i = 0; i < node->mNumMeshes;++i) {
-            ioprintf(io,"%u ",node->mMeshes[i]);
-        }
-        ioprintf(io,"\n%s\t</MeshRefs>\n",prefix);
-    }
-
-    if (node->mNumChildren) {
-        ioprintf(io,"%s\t<NodeList num=\"%u\">\n",
-            prefix,node->mNumChildren);
-
-        for (unsigned int i = 0; i < node->mNumChildren;++i) {
-            WriteNode(node->mChildren[i],io,depth+2);
-        }
-        ioprintf(io,"%s\t</NodeList>\n",prefix);
-    }
-    ioprintf(io,"%s</Node>\n",prefix);
-}
-
-
-// -----------------------------------------------------------------------------------
-// Some chuncks of text will need to be encoded for XML
-// http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
-static std::string encodeXML(const std::string& data) {
-    std::string buffer;
-    buffer.reserve(data.size());
-    for(size_t pos = 0; pos != data.size(); ++pos) {
-            switch(data[pos]) {
-                    case '&':  buffer.append("&amp;");              break;
-                    case '\"': buffer.append("&quot;");             break;
-                    case '\'': buffer.append("&apos;");             break;
-                    case '<':  buffer.append("&lt;");                   break;
-                    case '>':  buffer.append("&gt;");                   break;
-                    default:   buffer.append(&data[pos], 1);    break;
-            }
-    }
-    return buffer;
-}
-
-// -----------------------------------------------------------------------------------
-// Write a text model dump
-static
-void WriteDump(const char* pFile, const char* cmd, const aiScene* scene, IOStream* io, bool shortened) {
-    time_t tt = ::time( NULL );
-#if _WIN32
-    tm* p = gmtime(&tt);
-#else
-    struct tm now;
-    tm* p = gmtime_r(&tt, &now);
-#endif
-    ai_assert(nullptr != p);
-
-    std::string c = cmd;
-    std::string::size_type s; 
-
-    // https://sourceforge.net/tracker/?func=detail&aid=3167364&group_id=226462&atid=1067632
-    // -- not allowed in XML comments
-    while((s = c.find("--")) != std::string::npos) {
-        c[s] = '?';
-    }
-
-    // write header
-    std::string header(
-        "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
-        "<ASSIMP format_id=\"1\">\n\n"
-        "<!-- XML Model dump produced by assimp dump\n"
-        "  Library version: %u.%u.%u\n"
-        "  Source: %s\n"
-        "  Command line: %s\n"
-        "  %s\n"
-        "-->"
-        " \n\n"
-        "<Scene flags=\"%u\" postprocessing=\"%u\">\n"
-    );
-
-    const unsigned int majorVersion( aiGetVersionMajor() );
-    const unsigned int minorVersion( aiGetVersionMinor() );
-    const unsigned int rev( aiGetVersionRevision() );
-    const char *curtime( asctime( p ) );
-    ioprintf( io, header.c_str(), majorVersion, minorVersion, rev, pFile, c.c_str(), curtime, scene->mFlags, 0u );
-
-    // write the node graph
-    WriteNode(scene->mRootNode, io, 0);
-
-#if 0
-    // write cameras
-    for (unsigned int i = 0; i < scene->mNumCameras;++i) {
-        aiCamera* cam  = scene->mCameras[i];
-        ConvertName(name,cam->mName);
-
-        // camera header
-        ioprintf(io,"\t<Camera parent=\"%s\">\n"
-            "\t\t<Vector3 name=\"up\"        > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Float   name=\"fov\"       > %f </Float>\n"
-            "\t\t<Float   name=\"aspect\"    > %f </Float>\n"
-            "\t\t<Float   name=\"near_clip\" > %f </Float>\n"
-            "\t\t<Float   name=\"far_clip\"  > %f </Float>\n"
-            "\t</Camera>\n",
-            name.data,
-            cam->mUp.x,cam->mUp.y,cam->mUp.z,
-            cam->mLookAt.x,cam->mLookAt.y,cam->mLookAt.z,
-            cam->mPosition.x,cam->mPosition.y,cam->mPosition.z,
-            cam->mHorizontalFOV,cam->mAspect,cam->mClipPlaneNear,cam->mClipPlaneFar,i);
-    }
-
-    // write lights
-    for (unsigned int i = 0; i < scene->mNumLights;++i) {
-        aiLight* l  = scene->mLights[i];
-        ConvertName(name,l->mName);
-
-        // light header
-        ioprintf(io,"\t<Light parent=\"%s\"> type=\"%s\"\n"
-            "\t\t<Vector3 name=\"diffuse\"   > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"specular\"  > %0 8f %0 8f %0 8f </Vector3>\n"
-            "\t\t<Vector3 name=\"ambient\"   > %0 8f %0 8f %0 8f </Vector3>\n",
-            name.data,
-            (l->mType == aiLightSource_DIRECTIONAL ? "directional" :
-            (l->mType == aiLightSource_POINT ? "point" : "spot" )),
-            l->mColorDiffuse.r, l->mColorDiffuse.g, l->mColorDiffuse.b,
-            l->mColorSpecular.r,l->mColorSpecular.g,l->mColorSpecular.b,
-            l->mColorAmbient.r, l->mColorAmbient.g, l->mColorAmbient.b);
-
-        if (l->mType != aiLightSource_DIRECTIONAL) {
-            ioprintf(io,
-                "\t\t<Vector3 name=\"pos\"       > %0 8f %0 8f %0 8f </Vector3>\n"
-                "\t\t<Float   name=\"atten_cst\" > %f </Float>\n"
-                "\t\t<Float   name=\"atten_lin\" > %f </Float>\n"
-                "\t\t<Float   name=\"atten_sqr\" > %f </Float>\n",
-                l->mPosition.x,l->mPosition.y,l->mPosition.z,
-                l->mAttenuationConstant,l->mAttenuationLinear,l->mAttenuationQuadratic);
-        }
-
-        if (l->mType != aiLightSource_POINT) {
-            ioprintf(io,
-                "\t\t<Vector3 name=\"lookat\"    > %0 8f %0 8f %0 8f </Vector3>\n",
-                l->mDirection.x,l->mDirection.y,l->mDirection.z);
-        }
-
-        if (l->mType == aiLightSource_SPOT) {
-            ioprintf(io,
-                "\t\t<Float   name=\"cone_out\" > %f </Float>\n"
-                "\t\t<Float   name=\"cone_inn\" > %f </Float>\n",
-                l->mAngleOuterCone,l->mAngleInnerCone);
-        }
-        ioprintf(io,"\t</Light>\n");
-    }
-#endif
-    aiString name;
-
-    // write textures
-    if (scene->mNumTextures) {
-        ioprintf(io,"<TextureList num=\"%u\">\n",scene->mNumTextures);
-        for (unsigned int i = 0; i < scene->mNumTextures;++i) {
-            aiTexture* tex  = scene->mTextures[i];
-            bool compressed = (tex->mHeight == 0);
-
-            // mesh header
-            ioprintf(io,"\t<Texture width=\"%u\" height=\"%u\" compressed=\"%s\"> \n",
-                (compressed ? -1 : tex->mWidth),(compressed ? -1 : tex->mHeight),
-                (compressed ? "true" : "false"));
-
-            if (compressed) {
-                ioprintf(io,"\t\t<Data length=\"%u\"> \n",tex->mWidth);
-
-                if (!shortened) {
-                    for (unsigned int n = 0; n < tex->mWidth;++n) {
-                        ioprintf(io,"\t\t\t%2x",reinterpret_cast<uint8_t*>(tex->pcData)[n]);
-                        if (n && !(n % 50)) {
-                            ioprintf(io,"\n");
-                        }
-                    }
-                }
-            }
-            else if (!shortened){
-                ioprintf(io,"\t\t<Data length=\"%u\"> \n",tex->mWidth*tex->mHeight*4);
-
-                // const unsigned int width = (unsigned int)std::log10((double)std::max(tex->mHeight,tex->mWidth))+1;
-                for (unsigned int y = 0; y < tex->mHeight;++y) {
-                    for (unsigned int x = 0; x < tex->mWidth;++x) {
-                        aiTexel* tx = tex->pcData + y*tex->mWidth+x;
-                        unsigned int r = tx->r,g=tx->g,b=tx->b,a=tx->a;
-                        ioprintf(io,"\t\t\t%2x %2x %2x %2x",r,g,b,a);
-
-                        // group by four for readability
-                        if ( 0 == ( x + y*tex->mWidth ) % 4 ) {
-                            ioprintf( io, "\n" );
-                        }
-                    }
-                }
-            }
-            ioprintf(io,"\t\t</Data>\n\t</Texture>\n");
-        }
-        ioprintf(io,"</TextureList>\n");
-    }
-
-    // write materials
-    if (scene->mNumMaterials) {
-        ioprintf(io,"<MaterialList num=\"%u\">\n",scene->mNumMaterials);
-        for (unsigned int i = 0; i< scene->mNumMaterials; ++i) {
-            const aiMaterial* mat = scene->mMaterials[i];
-
-            ioprintf(io,"\t<Material>\n");
-            ioprintf(io,"\t\t<MatPropertyList  num=\"%u\">\n",mat->mNumProperties);
-            for (unsigned int n = 0; n < mat->mNumProperties;++n) {
-
-                const aiMaterialProperty* prop = mat->mProperties[n];
-                const char* sz = "";
-                if (prop->mType == aiPTI_Float) {
-                    sz = "float";
-                }
-                else if (prop->mType == aiPTI_Integer) {
-                    sz = "integer";
-                }
-                else if (prop->mType == aiPTI_String) {
-                    sz = "string";
-                }
-                else if (prop->mType == aiPTI_Buffer) {
-                    sz = "binary_buffer";
-                }
-
-                ioprintf(io,"\t\t\t<MatProperty key=\"%s\" \n\t\t\ttype=\"%s\" tex_usage=\"%s\" tex_index=\"%u\"",
-                    prop->mKey.data, sz,
-                    ::TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex);
-
-                if (prop->mType == aiPTI_Float) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength/sizeof(float)));
-
-                    for (unsigned int pp = 0; pp < prop->mDataLength/sizeof(float);++pp) {
-                        ioprintf(io,"%f ",*((float*)(prop->mData+pp*sizeof(float))));
-                    }
-                }
-                else if (prop->mType == aiPTI_Integer) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength/sizeof(int)));
-
-                    for (unsigned int pp = 0; pp < prop->mDataLength/sizeof(int);++pp) {
-                        ioprintf(io,"%i ",*((int*)(prop->mData+pp*sizeof(int))));
-                    }
-                }
-                else if (prop->mType == aiPTI_Buffer) {
-                    ioprintf(io," size=\"%i\">\n\t\t\t\t",
-                        static_cast<int>(prop->mDataLength));
-
-                    for (unsigned int pp = 0; pp< prop->mDataLength;++pp) {
-                        ioprintf(io,"%2x ",prop->mData[pp]);
-                        if (pp && 0 == pp%30) {
-                            ioprintf(io,"\n\t\t\t\t");
-                        }
-                    }
-                }
-                else if (prop->mType == aiPTI_String) {
-                    ioprintf(io,">\n\t\t\t\t\"%s\"",encodeXML(prop->mData+4).c_str() /* skip length */);
-                }
-                ioprintf(io,"\n\t\t\t</MatProperty>\n");
-            }
-            ioprintf(io,"\t\t</MatPropertyList>\n");
-            ioprintf(io,"\t</Material>\n");
-        }
-        ioprintf(io,"</MaterialList>\n");
-    }
-
-    // write animations
-    if (scene->mNumAnimations) {
-        ioprintf(io,"<AnimationList num=\"%u\">\n",scene->mNumAnimations);
-        for (unsigned int i = 0; i < scene->mNumAnimations;++i) {
-            aiAnimation* anim = scene->mAnimations[i];
-
-            // anim header
-            ConvertName(name,anim->mName);
-            ioprintf(io,"\t<Animation name=\"%s\" duration=\"%e\" tick_cnt=\"%e\">\n",
-                name.data, anim->mDuration, anim->mTicksPerSecond);
-
-            // write bone animation channels
-            if (anim->mNumChannels) {
-                ioprintf(io,"\t\t<NodeAnimList num=\"%u\">\n",anim->mNumChannels);
-                for (unsigned int n = 0; n < anim->mNumChannels;++n) {
-                    aiNodeAnim* nd = anim->mChannels[n];
-
-                    // node anim header
-                    ConvertName(name,nd->mNodeName);
-                    ioprintf(io,"\t\t\t<NodeAnim node=\"%s\">\n",name.data);
-
-                    if (!shortened) {
-                        // write position keys
-                        if (nd->mNumPositionKeys) {
-                            ioprintf(io,"\t\t\t\t<PositionKeyList num=\"%u\">\n",nd->mNumPositionKeys);
-                            for (unsigned int a = 0; a < nd->mNumPositionKeys;++a) {
-                                aiVectorKey* vc = nd->mPositionKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<PositionKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</PositionKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
-                            }
-                            ioprintf(io,"\t\t\t\t</PositionKeyList>\n");
-                        }
-
-                        // write scaling keys
-                        if (nd->mNumScalingKeys) {
-                            ioprintf(io,"\t\t\t\t<ScalingKeyList num=\"%u\">\n",nd->mNumScalingKeys);
-                            for (unsigned int a = 0; a < nd->mNumScalingKeys;++a) {
-                                aiVectorKey* vc = nd->mScalingKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<ScalingKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f\n\t\t\t\t\t</ScalingKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z);
-                            }
-                            ioprintf(io,"\t\t\t\t</ScalingKeyList>\n");
-                        }
-
-                        // write rotation keys
-                        if (nd->mNumRotationKeys) {
-                            ioprintf(io,"\t\t\t\t<RotationKeyList num=\"%u\">\n",nd->mNumRotationKeys);
-                            for (unsigned int a = 0; a < nd->mNumRotationKeys;++a) {
-                                aiQuatKey* vc = nd->mRotationKeys+a;
-                                ioprintf(io,"\t\t\t\t\t<RotationKey time=\"%e\">\n"
-                                    "\t\t\t\t\t\t%0 8f %0 8f %0 8f %0 8f\n\t\t\t\t\t</RotationKey>\n",
-                                    vc->mTime,vc->mValue.x,vc->mValue.y,vc->mValue.z,vc->mValue.w);
-                            }
-                            ioprintf(io,"\t\t\t\t</RotationKeyList>\n");
-                        }
-                    }
-                    ioprintf(io,"\t\t\t</NodeAnim>\n");
-                }
-                ioprintf(io,"\t\t</NodeAnimList>\n");
-            }
-            ioprintf(io,"\t</Animation>\n");
-        }
-        ioprintf(io,"</AnimationList>\n");
-    }
-
-    // write meshes
-    if (scene->mNumMeshes) {
-        ioprintf(io,"<MeshList num=\"%u\">\n",scene->mNumMeshes);
-        for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
-            aiMesh* mesh = scene->mMeshes[i];
-            // const unsigned int width = (unsigned int)std::log10((double)mesh->mNumVertices)+1;
-
-            // mesh header
-            ioprintf(io,"\t<Mesh types=\"%s %s %s %s\" material_index=\"%u\">\n",
-                (mesh->mPrimitiveTypes & aiPrimitiveType_POINT    ? "points"    : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_LINE     ? "lines"     : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_TRIANGLE ? "triangles" : ""),
-                (mesh->mPrimitiveTypes & aiPrimitiveType_POLYGON  ? "polygons"  : ""),
-                mesh->mMaterialIndex);
-
-            // bones
-            if (mesh->mNumBones) {
-                ioprintf(io,"\t\t<BoneList num=\"%u\">\n",mesh->mNumBones);
-
-                for (unsigned int n = 0; n < mesh->mNumBones;++n) {
-                    aiBone* bone = mesh->mBones[n];
-
-                    ConvertName(name,bone->mName);
-                    // bone header
-                    ioprintf(io,"\t\t\t<Bone name=\"%s\">\n"
-                        "\t\t\t\t<Matrix4> \n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t\t%0 6f %0 6f %0 6f %0 6f\n"
-                        "\t\t\t\t</Matrix4> \n",
-                        name.data,
-                        bone->mOffsetMatrix.a1,bone->mOffsetMatrix.a2,bone->mOffsetMatrix.a3,bone->mOffsetMatrix.a4,
-                        bone->mOffsetMatrix.b1,bone->mOffsetMatrix.b2,bone->mOffsetMatrix.b3,bone->mOffsetMatrix.b4,
-                        bone->mOffsetMatrix.c1,bone->mOffsetMatrix.c2,bone->mOffsetMatrix.c3,bone->mOffsetMatrix.c4,
-                        bone->mOffsetMatrix.d1,bone->mOffsetMatrix.d2,bone->mOffsetMatrix.d3,bone->mOffsetMatrix.d4);
-
-                    if (!shortened && bone->mNumWeights) {
-                        ioprintf(io,"\t\t\t\t<WeightList num=\"%u\">\n",bone->mNumWeights);
-
-                        // bone weights
-                        for (unsigned int a = 0; a < bone->mNumWeights;++a) {
-                            aiVertexWeight* wght = bone->mWeights+a;
-
-                            ioprintf(io,"\t\t\t\t\t<Weight index=\"%u\">\n\t\t\t\t\t\t%f\n\t\t\t\t\t</Weight>\n",
-                                wght->mVertexId,wght->mWeight);
-                        }
-                        ioprintf(io,"\t\t\t\t</WeightList>\n");
-                    }
-                    ioprintf(io,"\t\t\t</Bone>\n");
-                }
-                ioprintf(io,"\t\t</BoneList>\n");
-            }
-
-            // faces
-            if (!shortened && mesh->mNumFaces) {
-                ioprintf(io,"\t\t<FaceList num=\"%u\">\n",mesh->mNumFaces);
-                for (unsigned int n = 0; n < mesh->mNumFaces; ++n) {
-                    aiFace& f = mesh->mFaces[n];
-                    ioprintf(io,"\t\t\t<Face num=\"%u\">\n"
-                        "\t\t\t\t",f.mNumIndices);
-
-                    for (unsigned int j = 0; j < f.mNumIndices;++j)
-                        ioprintf(io,"%u ",f.mIndices[j]);
-
-                    ioprintf(io,"\n\t\t\t</Face>\n");
-                }
-                ioprintf(io,"\t\t</FaceList>\n");
-            }
-
-            // vertex positions
-            if (mesh->HasPositions()) {
-                ioprintf(io,"\t\t<Positions num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mVertices[n].x,
-                            mesh->mVertices[n].y,
-                            mesh->mVertices[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Positions>\n");
-            }
-
-            // vertex normals
-            if (mesh->HasNormals()) {
-                ioprintf(io,"\t\t<Normals num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mNormals[n].x,
-                            mesh->mNormals[n].y,
-                            mesh->mNormals[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Normals>\n");
-            }
-
-            // vertex tangents and bitangents
-            if (mesh->HasTangentsAndBitangents()) {
-                ioprintf(io,"\t\t<Tangents num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mTangents[n].x,
-                            mesh->mTangents[n].y,
-                            mesh->mTangents[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Tangents>\n");
-
-                ioprintf(io,"\t\t<Bitangents num=\"%u\" set=\"0\" num_components=\"3\"> \n",mesh->mNumVertices);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                            mesh->mBitangents[n].x,
-                            mesh->mBitangents[n].y,
-                            mesh->mBitangents[n].z);
-                    }
-                }
-                ioprintf(io,"\t\t</Bitangents>\n");
-            }
-
-            // texture coordinates
-            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a) {
-                if (!mesh->mTextureCoords[a])
-                    break;
-
-                ioprintf(io,"\t\t<TextureCoords num=\"%u\" set=\"%u\" num_components=\"%u\"> \n",mesh->mNumVertices,
-                    a,mesh->mNumUVComponents[a]);
-
-                if (!shortened) {
-                    if (mesh->mNumUVComponents[a] == 3) {
-                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                            ioprintf(io,"\t\t%0 8f %0 8f %0 8f\n",
-                                mesh->mTextureCoords[a][n].x,
-                                mesh->mTextureCoords[a][n].y,
-                                mesh->mTextureCoords[a][n].z);
-                        }
-                    }
-                    else {
-                        for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                            ioprintf(io,"\t\t%0 8f %0 8f\n",
-                                mesh->mTextureCoords[a][n].x,
-                                mesh->mTextureCoords[a][n].y);
-                        }
-                    }
-                }
-                ioprintf(io,"\t\t</TextureCoords>\n");
-            }
-
-            // vertex colors
-            for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a) {
-                if (!mesh->mColors[a])
-                    break;
-                ioprintf(io,"\t\t<Colors num=\"%u\" set=\"%u\" num_components=\"4\"> \n",mesh->mNumVertices,a);
-                if (!shortened) {
-                    for (unsigned int n = 0; n < mesh->mNumVertices; ++n) {
-                        ioprintf(io,"\t\t%0 8f %0 8f %0 8f %0 8f\n",
-                            mesh->mColors[a][n].r,
-                            mesh->mColors[a][n].g,
-                            mesh->mColors[a][n].b,
-                            mesh->mColors[a][n].a);
-                    }
-                }
-                ioprintf(io,"\t\t</Colors>\n");
-            }
-            ioprintf(io,"\t</Mesh>\n");
-        }
-        ioprintf(io,"</MeshList>\n");
-    }
-    ioprintf(io,"</Scene>\n</ASSIMP>");
-}
-
-} // end of namespace AssxmlFileWriter
-
-void DumpSceneToAssxml(
-    const char* pFile, const char* cmd, IOSystem* pIOSystem,
-    const aiScene* pScene, bool shortened) {
-    std::unique_ptr<IOStream> file(pIOSystem->Open(pFile, "wt"));
-    if (!file.get()) {
-        throw std::runtime_error("Unable to open output file " + std::string(pFile) + '\n');
-    }
-
-    AssxmlFileWriter::WriteDump(pFile, cmd, pScene, file.get(), shortened);
-}
-
-} // end of namespace Assimp
diff --git a/code/B3D/B3DImporter.cpp b/code/B3D/B3DImporter.cpp
deleted file mode 100644
index dbf002bd1..000000000
--- a/code/B3D/B3DImporter.cpp
+++ /dev/null
@@ -1,747 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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  B3DImporter.cpp
- *  @brief Implementation of the b3d importer class
- */
-
-
-#ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
-
-// internal headers
-#include "B3D/B3DImporter.h"
-#include "PostProcessing/TextureTransform.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/StringUtils.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/anim.h>
-#include <assimp/scene.h>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
-
-#include <memory>
-
-using namespace Assimp;
-using namespace std;
-
-static const aiImporterDesc desc = {
-    "BlitzBasic 3D Importer",
-    "",
-    "",
-    "http://www.blitzbasic.com/",
-    aiImporterFlags_SupportBinaryFlavour,
-    0,
-    0,
-    0,
-    0,
-    "b3d"
-};
-
-#ifdef _MSC_VER
-#	pragma warning (disable: 4018)
-#endif
-
-//#define DEBUG_B3D
-
-template<typename T>
-void DeleteAllBarePointers(std::vector<T>& x) {
-    for(auto p : x) {
-        delete p;
-    }
-}
-
-B3DImporter::~B3DImporter()
-{
-}
-
-// ------------------------------------------------------------------------------------------------
-bool B3DImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const{
-
-    size_t pos=pFile.find_last_of( '.' );
-    if( pos==string::npos ) {
-        return false;
-    }
-
-    string ext=pFile.substr( pos+1 );
-    if( ext.size()!=3 ) {
-        return false;
-    }
-
-    return (ext[0]=='b' || ext[0]=='B') && (ext[1]=='3') && (ext[2]=='d' || ext[2]=='D');
-}
-
-// ------------------------------------------------------------------------------------------------
-// Loader meta information
-const aiImporterDesc* B3DImporter::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::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 B3D file " + pFile + ".");
-    }
-
-    // check whether the .b3d file is large enough to contain
-    // at least one chunk.
-    size_t fileSize = file->FileSize();
-    if( fileSize<8 ) {
-        throw DeadlyImportError( "B3D File is too small.");
-    }
-
-    _pos=0;
-    _buf.resize( fileSize );
-    file->Read( &_buf[0],1,fileSize );
-    _stack.clear();
-
-    ReadBB3D( pScene );
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void B3DImporter::Oops(){
-    throw DeadlyImportError( "B3D Importer - INTERNAL ERROR" );
-}
-
-// ------------------------------------------------------------------------------------------------
-AI_WONT_RETURN void B3DImporter::Fail( string str ){
-#ifdef DEBUG_B3D
-    ASSIMP_LOG_ERROR_F("Error in B3D file data: ", str);
-#endif
-    throw DeadlyImportError( "B3D Importer - error in B3D file data: "+str );
-}
-
-// ------------------------------------------------------------------------------------------------
-int B3DImporter::ReadByte(){
-	if (_pos > _buf.size()) {
-		Fail("EOF");
-	}
-
-    return _buf[_pos++];
-}
-
-// ------------------------------------------------------------------------------------------------
-int B3DImporter::ReadInt(){
-	if (_pos + 4 > _buf.size()) {
-		Fail("EOF");
-    }
-
-    int n;
-    memcpy(&n, &_buf[_pos], 4);
-    _pos+=4;
-
-    return n;
-}
-
-// ------------------------------------------------------------------------------------------------
-float B3DImporter::ReadFloat() {
-	if (_pos + 4 > _buf.size()) {
-		Fail("EOF");
-	}
-
-    float n;
-    memcpy(&n, &_buf[_pos], 4);
-    _pos+=4;
-
-    return n;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector2D B3DImporter::ReadVec2(){
-    float x=ReadFloat();
-    float y=ReadFloat();
-    return aiVector2D( x,y );
-}
-
-// ------------------------------------------------------------------------------------------------
-aiVector3D B3DImporter::ReadVec3(){
-    float x=ReadFloat();
-    float y=ReadFloat();
-    float z=ReadFloat();
-    return aiVector3D( x,y,z );
-}
-
-// ------------------------------------------------------------------------------------------------
-aiQuaternion B3DImporter::ReadQuat(){
-    // (aramis_acg) Fix to adapt the loader to changed quat orientation
-    float w=-ReadFloat();
-    float x=ReadFloat();
-    float y=ReadFloat();
-    float z=ReadFloat();
-    return aiQuaternion( w,x,y,z );
-}
-
-// ------------------------------------------------------------------------------------------------
-string B3DImporter::ReadString(){
-	if (_pos > _buf.size()) {
-		Fail("EOF");
-	}
-    string str;
-    while( _pos<_buf.size() ){
-        char c=(char)ReadByte();
-        if( !c ) {
-            return str;
-        }
-        str+=c;
-    }
-    return string();
-}
-
-// ------------------------------------------------------------------------------------------------
-string B3DImporter::ReadChunk(){
-    string tag;
-    for( int i=0;i<4;++i ){
-        tag+=char( ReadByte() );
-    }
-#ifdef DEBUG_B3D
-    ASSIMP_LOG_DEBUG_F("ReadChunk: ", tag);
-#endif
-    unsigned sz=(unsigned)ReadInt();
-    _stack.push_back( _pos+sz );
-    return tag;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ExitChunk(){
-    _pos=_stack.back();
-    _stack.pop_back();
-}
-
-// ------------------------------------------------------------------------------------------------
-size_t B3DImporter::ChunkSize(){
-    return _stack.back()-_pos;
-}
-// ------------------------------------------------------------------------------------------------
-
-template<class T>
-T *B3DImporter::to_array( const vector<T> &v ){
-    if( v.empty() ) {
-        return 0;
-    }
-    T *p=new T[ v.size() ];
-    for( size_t i=0;i<v.size();++i ){
-        p[i]=v[i];
-    }
-    return p;
-}
-
-// ------------------------------------------------------------------------------------------------
-template<class T>
-T **unique_to_array( vector<std::unique_ptr<T> > &v ){
-    if( v.empty() ) {
-        return 0;
-    }
-    T **p = new T*[ v.size() ];
-    for( size_t i = 0; i < v.size(); ++i ){
-        p[i] = v[i].release();
-    }
-    return p;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTEXS(){
-    while( ChunkSize() ){
-        string name=ReadString();
-        /*int flags=*/ReadInt();
-        /*int blend=*/ReadInt();
-        /*aiVector2D pos=*/ReadVec2();
-        /*aiVector2D scale=*/ReadVec2();
-        /*float rot=*/ReadFloat();
-
-        _textures.push_back( name );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBRUS(){
-    int n_texs=ReadInt();
-    if( n_texs<0 || n_texs>8 ){
-        Fail( "Bad texture count" );
-    }
-    while( ChunkSize() ){
-        string name=ReadString();
-        aiVector3D color=ReadVec3();
-        float alpha=ReadFloat();
-        float shiny=ReadFloat();
-        /*int blend=**/ReadInt();
-        int fx=ReadInt();
-
-        std::unique_ptr<aiMaterial> mat(new aiMaterial);
-
-        // Name
-        aiString ainame( name );
-        mat->AddProperty( &ainame,AI_MATKEY_NAME );
-
-        // Diffuse color
-        mat->AddProperty( &color,1,AI_MATKEY_COLOR_DIFFUSE );
-
-        // Opacity
-        mat->AddProperty( &alpha,1,AI_MATKEY_OPACITY );
-
-        // Specular color
-        aiColor3D speccolor( shiny,shiny,shiny );
-        mat->AddProperty( &speccolor,1,AI_MATKEY_COLOR_SPECULAR );
-
-        // Specular power
-        float specpow=shiny*128;
-        mat->AddProperty( &specpow,1,AI_MATKEY_SHININESS );
-
-        // Double sided
-        if( fx & 0x10 ){
-            int i=1;
-            mat->AddProperty( &i,1,AI_MATKEY_TWOSIDED );
-        }
-
-        //Textures
-        for( int i=0;i<n_texs;++i ){
-            int texid=ReadInt();
-            if( texid<-1 || (texid>=0 && texid>=static_cast<int>(_textures.size())) ){
-                Fail( "Bad texture id" );
-            }
-            if( i==0 && texid>=0 ){
-                aiString texname( _textures[texid] );
-                mat->AddProperty( &texname,AI_MATKEY_TEXTURE_DIFFUSE(0) );
-            }
-        }
-        _materials.emplace_back( std::move(mat) );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadVRTS(){
-    _vflags=ReadInt();
-    _tcsets=ReadInt();
-    _tcsize=ReadInt();
-    if( _tcsets<0 || _tcsets>4 || _tcsize<0 || _tcsize>4 ){
-        Fail( "Bad texcoord data" );
-    }
-
-    int sz = 12+(_vflags&1?12:0)+(_vflags&2?16:0)+(_tcsets*_tcsize*4);
-    size_t n_verts = ChunkSize()/sz;
-
-    int v0=static_cast<int>(_vertices.size());
-    _vertices.resize( v0+n_verts );
-
-    for( unsigned int i=0;i<n_verts;++i ){
-        Vertex &v=_vertices[v0+i];
-
-        memset( v.bones,0,sizeof(v.bones) );
-        memset( v.weights,0,sizeof(v.weights) );
-
-        v.vertex=ReadVec3();
-
-        if( _vflags & 1 ) {
-            v.normal=ReadVec3();
-        }
-
-        if( _vflags & 2 ) {
-            ReadQuat();	//skip v 4bytes...
-        }
-
-        for( int j=0;j<_tcsets;++j ){
-            float t[4]={0,0,0,0};
-            for( int k=0;k<_tcsize;++k ){
-                t[k]=ReadFloat();
-            }
-            t[1] = 1 - t[1];
-            if( !j ) {
-                v.texcoords = aiVector3D( t[0],t[1],t[2] );
-            }
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadTRIS(int v0) {
-	int matid = ReadInt();
-	if (matid == -1) {
-		matid = 0;
-	} else if (matid < 0 || matid >= (int)_materials.size()) {
-#ifdef DEBUG_B3D
-		ASSIMP_LOG_ERROR_F("material id=", matid);
-#endif
-		Fail("Bad material id");
-	}
-
-	std::unique_ptr<aiMesh> mesh(new aiMesh);
-
-	mesh->mMaterialIndex = matid;
-	mesh->mNumFaces = 0;
-	mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
-
-	size_t n_tris = ChunkSize() / 12;
-	aiFace *face = mesh->mFaces = new aiFace[n_tris];
-
-    for (unsigned int i = 0; i < n_tris; ++i) {
-		int i0 = ReadInt() + v0;
-		int i1 = ReadInt() + v0;
-		int i2 = ReadInt() + v0;
-		if (i0 < 0 || i0 >= (int)_vertices.size() || i1 < 0 || i1 >= (int)_vertices.size() || i2 < 0 || i2 >= (int)_vertices.size()) {
-#ifdef DEBUG_B3D
-			ASSIMP_LOG_ERROR_F("Bad triangle index: i0=", i0, ", i1=", i1, ", i2=", i2);
-#endif
-			Fail("Bad triangle index");
-			continue;
-		}
-		face->mNumIndices = 3;
-		face->mIndices = new unsigned[3];
-		face->mIndices[0] = i0;
-		face->mIndices[1] = i1;
-		face->mIndices[2] = i2;
-		++mesh->mNumFaces;
-		++face;
-	}
-
-	_meshes.emplace_back(std::move(mesh));
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadMESH(){
-    /*int matid=*/ReadInt();
-
-    int v0= static_cast<int>(_vertices.size());
-
-    while( ChunkSize() ){
-        string t=ReadChunk();
-        if( t=="VRTS" ){
-            ReadVRTS();
-        }else if( t=="TRIS" ){
-            ReadTRIS( v0 );
-        }
-        ExitChunk();
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBONE(int id) {
-	while (ChunkSize()) {
-		int vertex = ReadInt();
-		float weight = ReadFloat();
-		if (vertex < 0 || vertex >= (int)_vertices.size()) {
-			Fail("Bad vertex index");
-		}
-
-		Vertex &v = _vertices[vertex];
-		for (int i = 0; i < 4; ++i) {
-			if (!v.weights[i]) {
-				v.bones[i] = static_cast<unsigned char>(id);
-				v.weights[i] = weight;
-				break;
-			}
-		}
-	}
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadKEYS( aiNodeAnim *nodeAnim ){
-    vector<aiVectorKey> trans,scale;
-    vector<aiQuatKey> rot;
-    int flags=ReadInt();
-    while( ChunkSize() ){
-        int frame=ReadInt();
-        if( flags & 1 ){
-            trans.push_back( aiVectorKey( frame,ReadVec3() ) );
-        }
-        if( flags & 2 ){
-            scale.push_back( aiVectorKey( frame,ReadVec3() ) );
-        }
-        if( flags & 4 ){
-            rot.push_back( aiQuatKey( frame,ReadQuat() ) );
-        }
-    }
-
-    if( flags & 1 ){
-        nodeAnim->mNumPositionKeys=static_cast<unsigned int>(trans.size());
-        nodeAnim->mPositionKeys=to_array( trans );
-    }
-
-    if( flags & 2 ){
-        nodeAnim->mNumScalingKeys=static_cast<unsigned int>(scale.size());
-        nodeAnim->mScalingKeys=to_array( scale );
-    }
-
-    if( flags & 4 ){
-        nodeAnim->mNumRotationKeys=static_cast<unsigned int>(rot.size());
-        nodeAnim->mRotationKeys=to_array( rot );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadANIM(){
-    /*int flags=*/ReadInt();
-    int frames=ReadInt();
-    float fps=ReadFloat();
-
-    std::unique_ptr<aiAnimation> anim(new aiAnimation);
-
-    anim->mDuration=frames;
-    anim->mTicksPerSecond=fps;
-    _animations.emplace_back( std::move(anim) );
-}
-
-// ------------------------------------------------------------------------------------------------
-aiNode *B3DImporter::ReadNODE( aiNode *parent ){
-
-    string name=ReadString();
-    aiVector3D t=ReadVec3();
-    aiVector3D s=ReadVec3();
-    aiQuaternion r=ReadQuat();
-
-    aiMatrix4x4 trans,scale,rot;
-
-    aiMatrix4x4::Translation( t,trans );
-    aiMatrix4x4::Scaling( s,scale );
-    rot=aiMatrix4x4( r.GetMatrix() );
-
-    aiMatrix4x4 tform=trans * rot * scale;
-
-    int nodeid=static_cast<int>(_nodes.size());
-
-    aiNode *node=new aiNode( name );
-    _nodes.push_back( node );
-
-    node->mParent=parent;
-    node->mTransformation=tform;
-
-    std::unique_ptr<aiNodeAnim> nodeAnim;
-    vector<unsigned> meshes;
-    vector<aiNode*> children;
-
-    while( ChunkSize() ){
-        const string chunk = ReadChunk();
-		if (chunk == "MESH") {
-            unsigned int n= static_cast<unsigned int>(_meshes.size());
-            ReadMESH();
-            for( unsigned int i=n;i<static_cast<unsigned int>(_meshes.size());++i ){
-                meshes.push_back( i );
-            }
-		} else if (chunk == "BONE") {
-            ReadBONE( nodeid );
-		} else if (chunk == "ANIM") {
-            ReadANIM();
-		} else if (chunk == "KEYS") {
-            if( !nodeAnim ){
-                nodeAnim.reset(new aiNodeAnim);
-                nodeAnim->mNodeName=node->mName;
-            }
-            ReadKEYS( nodeAnim.get() );
-		} else if (chunk == "NODE") {
-            aiNode *child=ReadNODE( node );
-            children.push_back( child );
-        }
-        ExitChunk();
-    }
-
-    if (nodeAnim) {
-        _nodeAnims.emplace_back( std::move(nodeAnim) );
-    }
-
-    node->mNumMeshes= static_cast<unsigned int>(meshes.size());
-    node->mMeshes=to_array( meshes );
-
-    node->mNumChildren=static_cast<unsigned int>(children.size());
-    node->mChildren=to_array( children );
-
-    return node;
-}
-
-// ------------------------------------------------------------------------------------------------
-void B3DImporter::ReadBB3D( aiScene *scene ){
-
-    _textures.clear();
-
-    _materials.clear();
-
-    _vertices.clear();
-
-    _meshes.clear();
-
-    DeleteAllBarePointers(_nodes);
-    _nodes.clear();
-
-    _nodeAnims.clear();
-
-    _animations.clear();
-
-    string t=ReadChunk();
-    if( t=="BB3D" ){
-        int version=ReadInt();
-
-        if (!DefaultLogger::isNullLogger()) {
-            char dmp[128];
-            ai_snprintf(dmp, 128, "B3D file format version: %i",version);
-            ASSIMP_LOG_INFO(dmp);
-        }
-
-        while( ChunkSize() ){
-            const string chunk = ReadChunk();
-			if (chunk == "TEXS") {
-                ReadTEXS();
-			} else if (chunk == "BRUS") {
-                ReadBRUS();
-			} else if (chunk == "NODE") {
-                ReadNODE( 0 );
-            }
-            ExitChunk();
-        }
-    }
-    ExitChunk();
-
-    if( !_nodes.size() ) {
-        Fail( "No nodes" );
-    }
-
-    if( !_meshes.size() ) {
-        Fail( "No meshes" );
-    }
-
-    // Fix nodes/meshes/bones
-    for(size_t i=0;i<_nodes.size();++i ){
-        aiNode *node=_nodes[i];
-
-        for( size_t j=0;j<node->mNumMeshes;++j ){
-            aiMesh *mesh = _meshes[node->mMeshes[j]].get();
-
-            int n_tris=mesh->mNumFaces;
-            int n_verts=mesh->mNumVertices=n_tris * 3;
-
-            aiVector3D *mv=mesh->mVertices=new aiVector3D[ n_verts ],*mn=0,*mc=0;
-            if( _vflags & 1 ) {
-                mn=mesh->mNormals=new aiVector3D[ n_verts ];
-            }
-            if( _tcsets ) {
-                mc=mesh->mTextureCoords[0]=new aiVector3D[ n_verts ];
-            }
-
-            aiFace *face=mesh->mFaces;
-
-            vector< vector<aiVertexWeight> > vweights( _nodes.size() );
-
-            for (int vertIdx = 0; vertIdx < n_verts; vertIdx += 3) {
-				for (int faceIndex = 0; faceIndex < 3; ++faceIndex) {
-					Vertex &v = _vertices[face->mIndices[faceIndex]];
-
-                    *mv++=v.vertex;
-                    if( mn ) *mn++=v.normal;
-                    if( mc ) *mc++=v.texcoords;
-
-                    face->mIndices[faceIndex] = vertIdx + faceIndex;
-
-                    for( int k=0;k<4;++k ){
-                        if( !v.weights[k] )
-                            break;
-
-                        int bone = v.bones[k];
-                        float weight = v.weights[k];
-
-                        vweights[bone].push_back(aiVertexWeight(vertIdx + faceIndex, weight));
-                    }
-                }
-                ++face;
-            }
-
-            vector<aiBone*> bones;
-			for (size_t weightIndx = 0; weightIndx < vweights.size(); ++weightIndx) {
-				vector<aiVertexWeight> &weights = vweights[weightIndx];
-				if (!weights.size()) {
-					continue;
-				}
-
-                aiBone *bone = new aiBone;
-                bones.push_back( bone );
-
-                aiNode *bnode = _nodes[weightIndx];
-
-                bone->mName = bnode->mName;
-                bone->mNumWeights = static_cast<unsigned int>(weights.size());
-                bone->mWeights = to_array( weights );
-
-                aiMatrix4x4 mat = bnode->mTransformation;
-                while( bnode->mParent ){
-                    bnode=bnode->mParent;
-                    mat=bnode->mTransformation * mat;
-                }
-                bone->mOffsetMatrix = mat.Inverse();
-            }
-            mesh->mNumBones= static_cast<unsigned int>(bones.size());
-            mesh->mBones=to_array( bones );
-        }
-    }
-
-    //nodes
-    scene->mRootNode=_nodes[0];
-    _nodes.clear();  // node ownership now belongs to scene
-
-    //material
-    if( !_materials.size() ){
-        _materials.emplace_back( std::unique_ptr<aiMaterial>(new aiMaterial) );
-    }
-    scene->mNumMaterials= static_cast<unsigned int>(_materials.size());
-    scene->mMaterials = unique_to_array( _materials );
-
-    //meshes
-    scene->mNumMeshes= static_cast<unsigned int>(_meshes.size());
-    scene->mMeshes = unique_to_array( _meshes );
-
-    //animations
-    if( _animations.size()==1 && _nodeAnims.size() ){
-
-        aiAnimation *anim = _animations.back().get();
-        anim->mNumChannels=static_cast<unsigned int>(_nodeAnims.size());
-        anim->mChannels = unique_to_array( _nodeAnims );
-
-        scene->mNumAnimations=static_cast<unsigned int>(_animations.size());
-        scene->mAnimations=unique_to_array( _animations );
-    }
-
-    // convert to RH
-    MakeLeftHandedProcess makeleft;
-    makeleft.Execute( scene );
-
-    FlipWindingOrderProcess flip;
-    flip.Execute( scene );
-}
-
-#endif // !! ASSIMP_BUILD_NO_B3D_IMPORTER
diff --git a/code/BVH/BVHLoader.cpp b/code/BVH/BVHLoader.cpp
deleted file mode 100644
index 1110754c2..000000000
--- a/code/BVH/BVHLoader.cpp
+++ /dev/null
@@ -1,578 +0,0 @@
-/** Implementation of the BVH loader */
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-copyright notice, this list of conditions and the
-following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the
-following disclaimer in the documentation and/or other
-materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-contributors may be used to endorse or promote products
-derived from this software without specific prior
-written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-
-#ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
-
-#include "BVHLoader.h"
-#include <assimp/fast_atof.h>
-#include <assimp/SkeletonMeshBuilder.h>
-#include <assimp/Importer.hpp>
-#include <memory>
-#include <assimp/TinyFormatter.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
-#include <assimp/importerdesc.h>
-#include <map>
-
-using namespace Assimp;
-using namespace Assimp::Formatter;
-
-static const aiImporterDesc desc = {
-    "BVH Importer (MoCap)",
-    "",
-    "",
-    "",
-    aiImporterFlags_SupportTextFlavour,
-    0,
-    0,
-    0,
-    0,
-    "bvh"
-};
-
-// ------------------------------------------------------------------------------------------------
-// Constructor to be privately used by Importer
-BVHLoader::BVHLoader()
-    : mLine(),
-    mAnimTickDuration(),
-    mAnimNumFrames(),
-    noSkeletonMesh()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor, private as well
-BVHLoader::~BVHLoader()
-{}
-
-// ------------------------------------------------------------------------------------------------
-// Returns whether the class can handle the format of the given file.
-bool BVHLoader::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool cs) const
-{
-    // check file extension
-    const std::string extension = GetExtension(pFile);
-
-    if( extension == "bvh")
-        return true;
-
-    if ((!extension.length() || cs) && pIOHandler) {
-        const char* tokens[] = {"HIERARCHY"};
-        return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
-    }
-    return false;
-}
-
-// ------------------------------------------------------------------------------------------------
-void BVHLoader::SetupProperties(const Importer* pImp)
-{
-    noSkeletonMesh = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_NO_SKELETON_MESHES,0) != 0;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Loader meta information
-const aiImporterDesc* BVHLoader::GetInfo () const
-{
-    return &desc;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Imports the given file into the given scene structure.
-void BVHLoader::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler)
-{
-    mFileName = pFile;
-
-    // read file into memory
-    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
-    if( file.get() == NULL)
-        throw DeadlyImportError( "Failed to open file " + pFile + ".");
-
-    size_t fileSize = file->FileSize();
-    if( fileSize == 0)
-        throw DeadlyImportError( "File is too small.");
-
-    mBuffer.resize( fileSize);
-    file->Read( &mBuffer.front(), 1, fileSize);
-
-    // start reading
-    mReader = mBuffer.begin();
-    mLine = 1;
-    ReadStructure( pScene);
-
-    if (!noSkeletonMesh) {
-        // build a dummy mesh for the skeleton so that we see something at least
-        SkeletonMeshBuilder meshBuilder( pScene);
-    }
-
-    // construct an animation from all the motion data we read
-    CreateAnimation( pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the file
-void BVHLoader::ReadStructure( aiScene* pScene)
-{
-    // first comes hierarchy
-    std::string header = GetNextToken();
-    if( header != "HIERARCHY")
-        ThrowException( "Expected header string \"HIERARCHY\".");
-    ReadHierarchy( pScene);
-
-    // then comes the motion data
-    std::string motion = GetNextToken();
-    if( motion != "MOTION")
-        ThrowException( "Expected beginning of motion data \"MOTION\".");
-    ReadMotion( pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the hierarchy
-void BVHLoader::ReadHierarchy( aiScene* pScene)
-{
-    std::string root = GetNextToken();
-    if( root != "ROOT")
-        ThrowException( "Expected root node \"ROOT\".");
-
-    // Go read the hierarchy from here
-    pScene->mRootNode = ReadNode();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a node and recursively its childs and returns the created node;
-aiNode* BVHLoader::ReadNode()
-{
-    // first token is name
-    std::string nodeName = GetNextToken();
-    if( nodeName.empty() || nodeName == "{")
-        ThrowException( format() << "Expected node name, but found \"" << nodeName << "\"." );
-
-    // then an opening brace should follow
-    std::string openBrace = GetNextToken();
-    if( openBrace != "{")
-        ThrowException( format() << "Expected opening brace \"{\", but found \"" << openBrace << "\"." );
-
-    // Create a node
-    aiNode* node = new aiNode( nodeName);
-    std::vector<aiNode*> childNodes;
-
-    // and create an bone entry for it
-    mNodes.push_back( Node( node));
-    Node& internNode = mNodes.back();
-
-    // now read the node's contents
-    std::string siteToken;
-    while( 1)
-    {
-        std::string token = GetNextToken();
-
-        // node offset to parent node
-        if( token == "OFFSET")
-            ReadNodeOffset( node);
-        else if( token == "CHANNELS")
-            ReadNodeChannels( internNode);
-        else if( token == "JOINT")
-        {
-            // child node follows
-            aiNode* child = ReadNode();
-            child->mParent = node;
-            childNodes.push_back( child);
-        }
-        else if( token == "End")
-        {
-            // The real symbol is "End Site". Second part comes in a separate token
-            siteToken.clear();
-            siteToken = GetNextToken();
-            if( siteToken != "Site")
-                ThrowException( format() << "Expected \"End Site\" keyword, but found \"" << token << " " << siteToken << "\"." );
-
-            aiNode* child = ReadEndSite( nodeName);
-            child->mParent = node;
-            childNodes.push_back( child);
-        }
-        else if( token == "}")
-        {
-            // we're done with that part of the hierarchy
-            break;
-        } else
-        {
-            // everything else is a parse error
-            ThrowException( format() << "Unknown keyword \"" << token << "\"." );
-        }
-    }
-
-    // add the child nodes if there are any
-    if( childNodes.size() > 0)
-    {
-        node->mNumChildren = static_cast<unsigned int>(childNodes.size());
-        node->mChildren = new aiNode*[node->mNumChildren];
-        std::copy( childNodes.begin(), childNodes.end(), node->mChildren);
-    }
-
-    // and return the sub-hierarchy we built here
-    return node;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads an end node and returns the created node.
-aiNode* BVHLoader::ReadEndSite( const std::string& pParentName)
-{
-    // check opening brace
-    std::string openBrace = GetNextToken();
-    if( openBrace != "{")
-        ThrowException( format() << "Expected opening brace \"{\", but found \"" << openBrace << "\".");
-
-    // Create a node
-    aiNode* node = new aiNode( "EndSite_" + pParentName);
-
-    // now read the node's contents. Only possible entry is "OFFSET"
-    std::string token;
-    while( 1) {
-        token.clear();
-        token = GetNextToken();
-
-        // end node's offset
-        if( token == "OFFSET") {
-            ReadNodeOffset( node);
-        } else if( token == "}") {
-            // we're done with the end node
-            break;
-        } else {
-            // everything else is a parse error
-            ThrowException( format() << "Unknown keyword \"" << token << "\"." );
-        }
-    }
-
-    // and return the sub-hierarchy we built here
-    return node;
-}
-// ------------------------------------------------------------------------------------------------
-// Reads a node offset for the given node
-void BVHLoader::ReadNodeOffset( aiNode* pNode)
-{
-    // Offset consists of three floats to read
-    aiVector3D offset;
-    offset.x = GetNextTokenAsFloat();
-    offset.y = GetNextTokenAsFloat();
-    offset.z = GetNextTokenAsFloat();
-
-    // build a transformation matrix from it
-    pNode->mTransformation = aiMatrix4x4( 1.0f, 0.0f, 0.0f, offset.x,
-                                          0.0f, 1.0f, 0.0f, offset.y,
-                                          0.0f, 0.0f, 1.0f, offset.z,
-                                          0.0f, 0.0f, 0.0f, 1.0f);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the animation channels for the given node
-void BVHLoader::ReadNodeChannels( BVHLoader::Node& pNode)
-{
-    // number of channels. Use the float reader because we're lazy
-    float numChannelsFloat = GetNextTokenAsFloat();
-    unsigned int numChannels = (unsigned int) numChannelsFloat;
-
-    for( unsigned int a = 0; a < numChannels; a++)
-    {
-        std::string channelToken = GetNextToken();
-
-        if( channelToken == "Xposition")
-            pNode.mChannels.push_back( Channel_PositionX);
-        else if( channelToken == "Yposition")
-            pNode.mChannels.push_back( Channel_PositionY);
-        else if( channelToken == "Zposition")
-            pNode.mChannels.push_back( Channel_PositionZ);
-        else if( channelToken == "Xrotation")
-            pNode.mChannels.push_back( Channel_RotationX);
-        else if( channelToken == "Yrotation")
-            pNode.mChannels.push_back( Channel_RotationY);
-        else if( channelToken == "Zrotation")
-            pNode.mChannels.push_back( Channel_RotationZ);
-        else
-            ThrowException( format() << "Invalid channel specifier \"" << channelToken << "\"." );
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the motion data
-void BVHLoader::ReadMotion( aiScene* /*pScene*/)
-{
-    // Read number of frames
-    std::string tokenFrames = GetNextToken();
-    if( tokenFrames != "Frames:")
-        ThrowException( format() << "Expected frame count \"Frames:\", but found \"" << tokenFrames << "\".");
-
-    float numFramesFloat = GetNextTokenAsFloat();
-    mAnimNumFrames = (unsigned int) numFramesFloat;
-
-    // Read frame duration
-    std::string tokenDuration1 = GetNextToken();
-    std::string tokenDuration2 = GetNextToken();
-    if( tokenDuration1 != "Frame" || tokenDuration2 != "Time:")
-        ThrowException( format() << "Expected frame duration \"Frame Time:\", but found \"" << tokenDuration1 << " " << tokenDuration2 << "\"." );
-
-    mAnimTickDuration = GetNextTokenAsFloat();
-
-    // resize value vectors for each node
-    for( std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
-        it->mChannelValues.reserve( it->mChannels.size() * mAnimNumFrames);
-
-    // now read all the data and store it in the corresponding node's value vector
-    for( unsigned int frame = 0; frame < mAnimNumFrames; ++frame)
-    {
-        // on each line read the values for all nodes
-        for( std::vector<Node>::iterator it = mNodes.begin(); it != mNodes.end(); ++it)
-        {
-            // get as many values as the node has channels
-            for( unsigned int c = 0; c < it->mChannels.size(); ++c)
-                it->mChannelValues.push_back( GetNextTokenAsFloat());
-        }
-
-        // after one frame worth of values for all nodes there should be a newline, but we better don't rely on it
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Retrieves the next token
-std::string BVHLoader::GetNextToken()
-{
-    // skip any preceding whitespace
-    while( mReader != mBuffer.end())
-    {
-        if( !isspace( *mReader))
-            break;
-
-        // count lines
-        if( *mReader == '\n')
-            mLine++;
-
-        ++mReader;
-    }
-
-    // collect all chars till the next whitespace. BVH is easy in respect to that.
-    std::string token;
-    while( mReader != mBuffer.end())
-    {
-        if( isspace( *mReader))
-            break;
-
-        token.push_back( *mReader);
-        ++mReader;
-
-        // little extra logic to make sure braces are counted correctly
-        if( token == "{" || token == "}")
-            break;
-    }
-
-    // empty token means end of file, which is just fine
-    return token;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads the next token as a float
-float BVHLoader::GetNextTokenAsFloat()
-{
-    std::string token = GetNextToken();
-    if( token.empty())
-        ThrowException( "Unexpected end of file while trying to read a float");
-
-    // check if the float is valid by testing if the atof() function consumed every char of the token
-    const char* ctoken = token.c_str();
-    float result = 0.0f;
-    ctoken = fast_atoreal_move<float>( ctoken, result);
-
-    if( ctoken != token.c_str() + token.length())
-        ThrowException( format() << "Expected a floating point number, but found \"" << token << "\"." );
-
-    return result;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Aborts the file reading with an exception
-AI_WONT_RETURN void BVHLoader::ThrowException( const std::string& pError)
-{
-    throw DeadlyImportError( format() << mFileName << ":" << mLine << " - " << pError);
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructs an animation for the motion data and stores it in the given scene
-void BVHLoader::CreateAnimation( aiScene* pScene)
-{
-    // create the animation
-    pScene->mNumAnimations = 1;
-    pScene->mAnimations = new aiAnimation*[1];
-    aiAnimation* anim = new aiAnimation;
-    pScene->mAnimations[0] = anim;
-
-    // put down the basic parameters
-    anim->mName.Set( "Motion");
-    anim->mTicksPerSecond = 1.0 / double( mAnimTickDuration);
-    anim->mDuration = double( mAnimNumFrames - 1);
-
-    // now generate the tracks for all nodes
-    anim->mNumChannels = static_cast<unsigned int>(mNodes.size());
-    anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
-
-    // FIX: set the array elements to NULL to ensure proper deletion if an exception is thrown
-    for (unsigned int i = 0; i < anim->mNumChannels;++i)
-        anim->mChannels[i] = NULL;
-
-    for( unsigned int a = 0; a < anim->mNumChannels; a++)
-    {
-        const Node& node = mNodes[a];
-        const std::string nodeName = std::string( node.mNode->mName.data );
-        aiNodeAnim* nodeAnim = new aiNodeAnim;
-        anim->mChannels[a] = nodeAnim;
-        nodeAnim->mNodeName.Set( nodeName);
-		std::map<BVHLoader::ChannelType, int> channelMap;
-
-		//Build map of channels 
-		for (unsigned int channel = 0; channel < node.mChannels.size(); ++channel)
-		{
-			channelMap[node.mChannels[channel]] = channel;
-		}
-
-        // translational part, if given
-        if( node.mChannels.size() == 6)
-        {
-            nodeAnim->mNumPositionKeys = mAnimNumFrames;
-            nodeAnim->mPositionKeys = new aiVectorKey[mAnimNumFrames];
-            aiVectorKey* poskey = nodeAnim->mPositionKeys;
-            for( unsigned int fr = 0; fr < mAnimNumFrames; ++fr)
-            {
-                poskey->mTime = double( fr);
-
-                // Now compute all translations 
-                for(BVHLoader::ChannelType channel = Channel_PositionX; channel <= Channel_PositionZ; channel = (BVHLoader::ChannelType)(channel +1))
-                {
-					//Find channel in node
-					std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
-
-					if (mapIter == channelMap.end())
-						throw DeadlyImportError("Missing position channel in node " + nodeName);
-					else {
-						int channelIdx = mapIter->second;
-						switch (channel) {
-						    case Channel_PositionX: 
-                                poskey->mValue.x = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
-                                break;
-						    case Channel_PositionY: 
-                                poskey->mValue.y = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
-                                break;
-						    case Channel_PositionZ: 
-                                poskey->mValue.z = node.mChannelValues[fr * node.mChannels.size() + channelIdx]; 
-                                break;
-                                
-                            default:
-                                break;
-						}
-
-					}
-                }
-                ++poskey;
-            }
-        } else
-        {
-            // if no translation part is given, put a default sequence
-            aiVector3D nodePos( node.mNode->mTransformation.a4, node.mNode->mTransformation.b4, node.mNode->mTransformation.c4);
-            nodeAnim->mNumPositionKeys = 1;
-            nodeAnim->mPositionKeys = new aiVectorKey[1];
-            nodeAnim->mPositionKeys[0].mTime = 0.0;
-            nodeAnim->mPositionKeys[0].mValue = nodePos;
-        }
-
-        // rotation part. Always present. First find value offsets
-        {
-
-            // Then create the number of rotation keys
-            nodeAnim->mNumRotationKeys = mAnimNumFrames;
-            nodeAnim->mRotationKeys = new aiQuatKey[mAnimNumFrames];
-            aiQuatKey* rotkey = nodeAnim->mRotationKeys;
-            for( unsigned int fr = 0; fr < mAnimNumFrames; ++fr)
-            {
-                aiMatrix4x4 temp;
-                aiMatrix3x3 rotMatrix;
-				for (BVHLoader::ChannelType channel = Channel_RotationX; channel <= Channel_RotationZ; channel = (BVHLoader::ChannelType)(channel + 1))
-				{
-					//Find channel in node
-					std::map<BVHLoader::ChannelType, int>::iterator mapIter = channelMap.find(channel);
-
-					if (mapIter == channelMap.end())
-						throw DeadlyImportError("Missing rotation channel in node " + nodeName);
-					else {
-						int channelIdx = mapIter->second;
-						// translate ZXY euler angels into a quaternion
-						const float angle = node.mChannelValues[fr * node.mChannels.size() + channelIdx] * float(AI_MATH_PI) / 180.0f;
-
-						// Compute rotation transformations in the right order
-						switch (channel)
-						{
-							case Channel_RotationX: 
-                                aiMatrix4x4::RotationX(angle, temp); rotMatrix *= aiMatrix3x3(temp); 
-                                break;
-							case Channel_RotationY: 
-                                aiMatrix4x4::RotationY(angle, temp); rotMatrix *= aiMatrix3x3(temp);  
-                                break;
-							case Channel_RotationZ: aiMatrix4x4::RotationZ(angle, temp); rotMatrix *= aiMatrix3x3(temp); 
-                                break;
-                            default:
-                                break;
-						}
-					}
-                }
-
-                rotkey->mTime = double( fr);
-                rotkey->mValue = aiQuaternion( rotMatrix);
-                ++rotkey;
-            }
-        }
-
-        // scaling part. Always just a default track
-        {
-            nodeAnim->mNumScalingKeys = 1;
-            nodeAnim->mScalingKeys = new aiVectorKey[1];
-            nodeAnim->mScalingKeys[0].mTime = 0.0;
-            nodeAnim->mScalingKeys[0].mValue.Set( 1.0f, 1.0f, 1.0f);
-        }
-    }
-}
-
-#endif // !! ASSIMP_BUILD_NO_BVH_IMPORTER
diff --git a/code/Blender/BlenderCustomData.cpp b/code/Blender/BlenderCustomData.cpp
deleted file mode 100644
index 6561eaf22..000000000
--- a/code/Blender/BlenderCustomData.cpp
+++ /dev/null
@@ -1,189 +0,0 @@
-#include "BlenderCustomData.h"
-#include "BlenderDNA.h"
-#include <array>
-#include <functional>
-
-namespace Assimp {
-    namespace Blender {
-        /**
-        *   @brief  read/convert of Structure array to memory
-        */
-        template<typename T>
-        bool read(const Structure &s, T *p, const size_t cnt, const FileDatabase &db) {
-            for (size_t i = 0; i < cnt; ++i) {
-                T read;
-                s.Convert(read, db);
-                *p = read;
-                p++;
-            }
-            return true;
-        }
-
-        /**
-        *   @brief  pointer to function read memory for n CustomData types
-        */
-        typedef bool        (*PRead)(ElemBase *pOut, const size_t cnt, const FileDatabase &db);
-        typedef ElemBase *  (*PCreate)(const size_t cnt);
-        typedef void(*PDestroy)(ElemBase *);
-
-#define IMPL_STRUCT_READ(ty)                                                    \
-        bool read##ty(ElemBase *v, const size_t cnt, const FileDatabase &db) {  \
-        ty *ptr = dynamic_cast<ty*>(v);                                         \
-        if (nullptr == ptr) {                                                   \
-            return false;                                                       \
-        }                                                                       \
-        return read<ty>(db.dna[#ty], ptr, cnt, db);                             \
-        }
-
-#define IMPL_STRUCT_CREATE(ty)                                                  \
-        ElemBase *create##ty(const size_t cnt) {                                \
-            return new ty[cnt];                                                 \
-        }
-
-#define IMPL_STRUCT_DESTROY(ty)                                                 \
-        void destroy##ty(ElemBase *pE) {                                        \
-            ty *p = dynamic_cast<ty *>(pE);                                     \
-            delete[]p;                                                          \
-        }
-
-        /**
-        *   @brief  helper macro to define Structure functions
-        */
-#define IMPL_STRUCT(ty)                                                         \
-        IMPL_STRUCT_READ(ty)                                                    \
-        IMPL_STRUCT_CREATE(ty)                                                  \
-        IMPL_STRUCT_DESTROY(ty)
-
-        // supported structures for CustomData
-        IMPL_STRUCT(MVert)
-        IMPL_STRUCT(MEdge)
-        IMPL_STRUCT(MFace)
-        IMPL_STRUCT(MTFace)
-        IMPL_STRUCT(MTexPoly)
-        IMPL_STRUCT(MLoopUV)
-        IMPL_STRUCT(MLoopCol)
-        IMPL_STRUCT(MPoly)
-        IMPL_STRUCT(MLoop)
-
-        /**
-        *   @brief  describes the size of data and the read function to be used for single CustomerData.type
-        */
-        struct CustomDataTypeDescription {
-            PRead Read;                         ///< function to read one CustomData type element
-            PCreate Create;                       ///< function to allocate n type elements
-            PDestroy Destroy;
-
-            CustomDataTypeDescription(PRead read, PCreate create, PDestroy destroy)
-                : Read(read)
-                , Create(create)
-                , Destroy(destroy)
-            {}
-        };
-
-
-        /**
-        *   @brief  helper macro to define Structure type specific CustomDataTypeDescription
-        *   @note   IMPL_STRUCT_READ for same ty must be used earlier to implement the typespecific read function
-        */
-#define DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(ty)           \
-        CustomDataTypeDescription{&read##ty, &create##ty, &destroy##ty}
-
-        /**
-        *   @brief  helper macro to define CustomDataTypeDescription for UNSUPPORTED type
-        */
-#define DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION          \
-        CustomDataTypeDescription{nullptr, nullptr, nullptr}
-
-        /**
-        *   @brief  descriptors for data pointed to from CustomDataLayer.data
-        *   @note   some of the CustomData uses already well defined Structures
-        *           other (like CD_ORCO, ...) uses arrays of rawtypes or even arrays of Structures
-        *           use a special readfunction for that cases
-        */
-        std::array<CustomDataTypeDescription, CD_NUMTYPES> customDataTypeDescriptions = { {
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MVert),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MEdge),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MFace),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTFace),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MTexPoly),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopUV),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoopCol),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MPoly),
-            DECL_STRUCT_CUSTOMDATATYPEDESCRIPTION(MLoop),
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION,
-            DECL_UNSUPPORTED_CUSTOMDATATYPEDESCRIPTION
-        }};
-
-
-        bool isValidCustomDataType(const int cdtype) {
-            return cdtype >= 0 && cdtype < CD_NUMTYPES;
-        }
-
-        bool readCustomData(std::shared_ptr<ElemBase> &out, const int cdtype, const size_t cnt, const FileDatabase &db) {
-            if (!isValidCustomDataType(cdtype)) {
-                throw Error((Formatter::format(), "CustomData.type ", cdtype, " out of index"));
-            }
-
-            const CustomDataTypeDescription cdtd = customDataTypeDescriptions[cdtype];
-            if (cdtd.Read && cdtd.Create && cdtd.Destroy && cnt > 0) {
-                // allocate cnt elements and parse them from file
-                out.reset(cdtd.Create(cnt), cdtd.Destroy);
-                return cdtd.Read(out.get(), cnt, db);
-            }
-            return false;
-        }
-
-        std::shared_ptr<CustomDataLayer> getCustomDataLayer(const CustomData &customdata, const CustomDataType cdtype, const std::string &name) {
-            for (auto it = customdata.layers.begin(); it != customdata.layers.end(); ++it) {
-                if (it->get()->type == cdtype && name == it->get()->name) {
-                    return *it;
-                }
-            }
-            return nullptr;
-        }
-
-        const ElemBase * getCustomDataLayerData(const CustomData &customdata, const CustomDataType cdtype, const std::string &name)
-        {
-            const std::shared_ptr<CustomDataLayer> pLayer = getCustomDataLayer(customdata, cdtype, name);
-            if (pLayer && pLayer->data) {
-                return pLayer->data.get();
-            }
-            return nullptr;
-        }
-    }
-}
diff --git a/code/Blender/BlenderScene.cpp b/code/Blender/BlenderScene.cpp
deleted file mode 100644
index 1391a2833..000000000
--- a/code/Blender/BlenderScene.cpp
+++ /dev/null
@@ -1,875 +0,0 @@
-/*
-Open Asset Import Library (ASSIMP)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, ASSIMP Development 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 Development 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  BlenderScene.cpp
- *  @brief MACHINE GENERATED BY ./scripts/BlenderImporter/genblenddna.py
- */
-
-#ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
-
-#include "BlenderScene.h"
-#include "BlenderSceneGen.h"
-#include "BlenderDNA.h"
-#include "BlenderCustomData.h"
-
-using namespace Assimp;
-using namespace Assimp::Blender;
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Object> (
-    Object& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    int temp = 0;
-    ReadField<ErrorPolicy_Fail>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Object::Type>(temp);
-    ReadFieldArray2<ErrorPolicy_Warn>(dest.obmat,"obmat",db);
-    ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv,"parentinv",db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr,"parsubstr",db);
-    {
-        std::shared_ptr<Object> parent;
-        ReadFieldPtr<ErrorPolicy_Warn>(parent,"*parent",db);
-        dest.parent = parent.get();
-    }
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.track,"*track",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy,"*proxy",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_from,"*proxy_from",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.proxy_group,"*proxy_group",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.dup_group,"*dup_group",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.data,"*data",db);
-    ReadField<ErrorPolicy_Igno>(dest.modifiers,"modifiers",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Group> (
-    Group& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Igno>(dest.layer,"layer",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.gobject,"*gobject",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MTex> (
-    MTex& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    int temp_short = 0;
-    ReadField<ErrorPolicy_Igno>(temp_short,"mapto",db);
-    dest.mapto = static_cast<Assimp::Blender::MTex::MapType>(temp_short);
-    int temp = 0;
-    ReadField<ErrorPolicy_Igno>(temp,"blendtype",db);
-    dest.blendtype = static_cast<Assimp::Blender::MTex::BlendType>(temp);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.object,"*object",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.tex,"*tex",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.uvname,"uvname",db);
-    ReadField<ErrorPolicy_Igno>(temp,"projx",db);
-    dest.projx = static_cast<Assimp::Blender::MTex::Projection>(temp);
-    ReadField<ErrorPolicy_Igno>(temp,"projy",db);
-    dest.projy = static_cast<Assimp::Blender::MTex::Projection>(temp);
-    ReadField<ErrorPolicy_Igno>(temp,"projz",db);
-    dest.projz = static_cast<Assimp::Blender::MTex::Projection>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.mapping,"mapping",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.ofs,"ofs",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.size,"size",db);
-    ReadField<ErrorPolicy_Igno>(dest.rot,"rot",db);
-    ReadField<ErrorPolicy_Igno>(dest.texflag,"texflag",db);
-    ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
-    ReadField<ErrorPolicy_Igno>(dest.pmapto,"pmapto",db);
-    ReadField<ErrorPolicy_Igno>(dest.pmaptoneg,"pmaptoneg",db);
-    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Warn>(dest.k,"k",db);
-    ReadField<ErrorPolicy_Igno>(dest.colspecfac,"colspecfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirrfac,"mirrfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.alphafac,"alphafac",db);
-    ReadField<ErrorPolicy_Igno>(dest.difffac,"difffac",db);
-    ReadField<ErrorPolicy_Igno>(dest.specfac,"specfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.emitfac,"emitfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.hardfac,"hardfac",db);
-    ReadField<ErrorPolicy_Igno>(dest.norfac,"norfac",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<TFace> (
-    TFace& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv,"uv",db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.col,"col",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
-    ReadField<ErrorPolicy_Igno>(dest.unwrap,"unwrap",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<SubsurfModifierData> (
-    SubsurfModifierData& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.modifier,"modifier",db);
-    ReadField<ErrorPolicy_Warn>(dest.subdivType,"subdivType",db);
-    ReadField<ErrorPolicy_Fail>(dest.levels,"levels",db);
-    ReadField<ErrorPolicy_Igno>(dest.renderLevels,"renderLevels",db);
-    ReadField<ErrorPolicy_Igno>(dest.flags,"flags",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MFace> (
-    MFace& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.v1,"v1",db);
-    ReadField<ErrorPolicy_Fail>(dest.v2,"v2",db);
-    ReadField<ErrorPolicy_Fail>(dest.v3,"v3",db);
-    ReadField<ErrorPolicy_Fail>(dest.v4,"v4",db);
-    ReadField<ErrorPolicy_Fail>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Lamp> (
-    Lamp& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    int temp = 0;
-    ReadField<ErrorPolicy_Fail>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Lamp::Type>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.flags,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.colormodel,"colormodel",db);
-    ReadField<ErrorPolicy_Igno>(dest.totex,"totex",db);
-    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Warn>(dest.k,"k",db);
-    ReadField<ErrorPolicy_Igno>(dest.energy,"energy",db);
-    ReadField<ErrorPolicy_Warn>(dest.dist,"dist",db);
-    ReadField<ErrorPolicy_Igno>(dest.spotsize,"spotsize",db);
-    ReadField<ErrorPolicy_Igno>(dest.spotblend,"spotblend",db);
-    ReadField<ErrorPolicy_Warn>(dest.constant_coefficient, "coeff_const", db);
-    ReadField<ErrorPolicy_Warn>(dest.linear_coefficient, "coeff_lin", db);
-    ReadField<ErrorPolicy_Warn>(dest.quadratic_coefficient, "coeff_quad", db);
-    ReadField<ErrorPolicy_Igno>(dest.att1,"att1",db);
-    ReadField<ErrorPolicy_Igno>(dest.att2,"att2",db);
-    ReadField<ErrorPolicy_Igno>(temp,"falloff_type",db);
-    dest.falloff_type = static_cast<Assimp::Blender::Lamp::FalloffType>(temp);
-    ReadField<ErrorPolicy_Igno>(dest.sun_brightness,"sun_brightness",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_size,"area_size",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_sizey,"area_sizey",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_sizez,"area_sizez",db);
-    ReadField<ErrorPolicy_Igno>(dest.area_shape,"area_shape",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MDeformWeight> (
-    MDeformWeight& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.def_nr,"def_nr",db);
-    ReadField<ErrorPolicy_Fail>(dest.weight,"weight",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<PackedFile> (
-    PackedFile& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Warn>(dest.size,"size",db);
-    ReadField<ErrorPolicy_Warn>(dest.seek,"seek",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.data,"*data",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Base> (
-    Base& dest,
-    const FileDatabase& db
-    ) const
-{
-    // note: as per https://github.com/assimp/assimp/issues/128,
-    // reading the Object linked list recursively is prone to stack overflow.
-    // This structure converter is therefore an hand-written exception that
-    // does it iteratively.
-
-    const int initial_pos = db.reader->GetCurrentPos();
-
-    std::pair<Base*, int> todo = std::make_pair(&dest, initial_pos);
-    for ( ;; ) {
-
-        Base& cur_dest = *todo.first;
-        db.reader->SetCurrentPos(todo.second);
-
-        // we know that this is a double-linked, circular list which we never
-        // traverse backwards, so don't bother resolving the back links.
-        cur_dest.prev = NULL;
-
-        ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.object,"*object",db);
-
-        // the return value of ReadFieldPtr indicates whether the object
-        // was already cached. In this case, we don't need to resolve
-        // it again.
-        if(!ReadFieldPtr<ErrorPolicy_Warn>(cur_dest.next,"*next",db, true) && cur_dest.next) {
-            todo = std::make_pair(&*cur_dest.next, db.reader->GetCurrentPos());
-            continue;
-        }
-        break;
-    }
-
-    db.reader->SetCurrentPos(initial_pos + size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MTFace> (
-    MTFace& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray2<ErrorPolicy_Fail>(dest.uv,"uv",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
-    ReadField<ErrorPolicy_Igno>(dest.unwrap,"unwrap",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Material> (
-    Material& dest,
-    const FileDatabase& db
-    ) const
-{
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Warn>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Warn>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Warn>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Warn>(dest.specr,"specr",db);
-    ReadField<ErrorPolicy_Warn>(dest.specg,"specg",db);
-    ReadField<ErrorPolicy_Warn>(dest.specb,"specb",db);
-    ReadField<ErrorPolicy_Igno>(dest.har,"har",db);
-    ReadField<ErrorPolicy_Warn>(dest.ambr,"ambr",db);
-    ReadField<ErrorPolicy_Warn>(dest.ambg,"ambg",db);
-    ReadField<ErrorPolicy_Warn>(dest.ambb,"ambb",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirr,"mirr",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirg,"mirg",db);
-    ReadField<ErrorPolicy_Igno>(dest.mirb,"mirb",db);
-    ReadField<ErrorPolicy_Warn>(dest.emit,"emit",db);
-    ReadField<ErrorPolicy_Igno>(dest.ray_mirror,"ray_mirror",db);
-    ReadField<ErrorPolicy_Warn>(dest.alpha,"alpha",db);
-    ReadField<ErrorPolicy_Igno>(dest.ref,"ref",db);
-    ReadField<ErrorPolicy_Igno>(dest.translucency,"translucency",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.roughness,"roughness",db);
-    ReadField<ErrorPolicy_Igno>(dest.darkness,"darkness",db);
-    ReadField<ErrorPolicy_Igno>(dest.refrac,"refrac",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.group,"*group",db);
-    ReadField<ErrorPolicy_Warn>(dest.diff_shader,"diff_shader",db);
-    ReadField<ErrorPolicy_Warn>(dest.spec_shader,"spec_shader",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtex,"*mtex",db);
-
-
-    ReadField<ErrorPolicy_Igno>(dest.amb, "amb", db);
-    ReadField<ErrorPolicy_Igno>(dest.ang, "ang", db);
-    ReadField<ErrorPolicy_Igno>(dest.spectra, "spectra", db);
-    ReadField<ErrorPolicy_Igno>(dest.spec, "spec", db);
-    ReadField<ErrorPolicy_Igno>(dest.zoffs, "zoffs", db);
-    ReadField<ErrorPolicy_Igno>(dest.add, "add", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir, "fresnel_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_mir_i, "fresnel_mir_i", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra, "fresnel_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.fresnel_tra_i, "fresnel_tra_i", db);
-    ReadField<ErrorPolicy_Igno>(dest.filter, "filter", db);
-    ReadField<ErrorPolicy_Igno>(dest.tx_limit, "tx_limit", db);
-    ReadField<ErrorPolicy_Igno>(dest.tx_falloff, "tx_falloff", db);
-    ReadField<ErrorPolicy_Igno>(dest.gloss_mir, "gloss_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.gloss_tra, "gloss_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_mir, "adapt_thresh_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.adapt_thresh_tra, "adapt_thresh_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.aniso_gloss_mir, "aniso_gloss_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.dist_mir, "dist_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.hasize, "hasize", db);
-    ReadField<ErrorPolicy_Igno>(dest.flaresize, "flaresize", db);
-    ReadField<ErrorPolicy_Igno>(dest.subsize, "subsize", db);
-    ReadField<ErrorPolicy_Igno>(dest.flareboost, "flareboost", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_sta, "strand_sta", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_end, "strand_end", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_ease, "strand_ease", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_surfnor, "strand_surfnor", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_min, "strand_min", db);
-    ReadField<ErrorPolicy_Igno>(dest.strand_widthfade, "strand_widthfade", db);
-    ReadField<ErrorPolicy_Igno>(dest.sbias, "sbias", db);
-    ReadField<ErrorPolicy_Igno>(dest.lbias, "lbias", db);
-    ReadField<ErrorPolicy_Igno>(dest.shad_alpha, "shad_alpha", db);
-    ReadField<ErrorPolicy_Igno>(dest.param, "param", db);
-    ReadField<ErrorPolicy_Igno>(dest.rms, "rms", db);
-    ReadField<ErrorPolicy_Igno>(dest.rampfac_col, "rampfac_col", db);
-    ReadField<ErrorPolicy_Igno>(dest.rampfac_spec, "rampfac_spec", db);
-    ReadField<ErrorPolicy_Igno>(dest.friction, "friction", db);
-    ReadField<ErrorPolicy_Igno>(dest.fh, "fh", db);
-    ReadField<ErrorPolicy_Igno>(dest.reflect, "reflect", db);
-    ReadField<ErrorPolicy_Igno>(dest.fhdist, "fhdist", db);
-    ReadField<ErrorPolicy_Igno>(dest.xyfrict, "xyfrict", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_radius, "sss_radius", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_col, "sss_col", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_error, "sss_error", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_scale, "sss_scale", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_ior, "sss_ior", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_colfac, "sss_colfac", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_texfac, "sss_texfac", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_front, "sss_front", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_back, "sss_back", db);
-
-    ReadField<ErrorPolicy_Igno>(dest.material_type, "material_type", db);
-    ReadField<ErrorPolicy_Igno>(dest.flag, "flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.ray_depth, "ray_depth", db);
-    ReadField<ErrorPolicy_Igno>(dest.ray_depth_tra, "ray_depth_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_mir, "samp_gloss_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.samp_gloss_tra, "samp_gloss_tra", db);
-    ReadField<ErrorPolicy_Igno>(dest.fadeto_mir, "fadeto_mir", db);
-    ReadField<ErrorPolicy_Igno>(dest.shade_flag, "shade_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.flarec, "flarec", db);
-    ReadField<ErrorPolicy_Igno>(dest.starc, "starc", db);
-    ReadField<ErrorPolicy_Igno>(dest.linec, "linec", db);
-    ReadField<ErrorPolicy_Igno>(dest.ringc, "ringc", db);
-    ReadField<ErrorPolicy_Igno>(dest.pr_lamp, "pr_lamp", db);
-    ReadField<ErrorPolicy_Igno>(dest.pr_texture, "pr_texture", db);
-    ReadField<ErrorPolicy_Igno>(dest.ml_flag, "ml_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.diff_shader, "diff_shader", db);
-    ReadField<ErrorPolicy_Igno>(dest.spec_shader, "spec_shader", db);
-    ReadField<ErrorPolicy_Igno>(dest.texco, "texco", db);
-    ReadField<ErrorPolicy_Igno>(dest.mapto, "mapto", db);
-    ReadField<ErrorPolicy_Igno>(dest.ramp_show, "ramp_show", db);
-    ReadField<ErrorPolicy_Igno>(dest.pad3, "pad3", db);
-    ReadField<ErrorPolicy_Igno>(dest.dynamode, "dynamode", db);
-    ReadField<ErrorPolicy_Igno>(dest.pad2, "pad2", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_flag, "sss_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.sss_preset, "sss_preset", db);
-    ReadField<ErrorPolicy_Igno>(dest.shadowonly_flag, "shadowonly_flag", db);
-    ReadField<ErrorPolicy_Igno>(dest.index, "index", db);
-    ReadField<ErrorPolicy_Igno>(dest.vcol_alpha, "vcol_alpha", db);
-    ReadField<ErrorPolicy_Igno>(dest.pad4, "pad4", db);
-
-    ReadField<ErrorPolicy_Igno>(dest.seed1, "seed1", db);
-    ReadField<ErrorPolicy_Igno>(dest.seed2, "seed2", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MTexPoly> (
-    MTexPoly& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    {
-        std::shared_ptr<Image> tpage;
-        ReadFieldPtr<ErrorPolicy_Igno>(tpage,"*tpage",db);
-        dest.tpage = tpage.get();
-    }
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.transp,"transp",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadField<ErrorPolicy_Igno>(dest.tile,"tile",db);
-    ReadField<ErrorPolicy_Igno>(dest.pad,"pad",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Mesh> (
-    Mesh& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadField<ErrorPolicy_Fail>(dest.totface,"totface",db);
-    ReadField<ErrorPolicy_Fail>(dest.totedge,"totedge",db);
-    ReadField<ErrorPolicy_Fail>(dest.totvert,"totvert",db);
-    ReadField<ErrorPolicy_Igno>(dest.totloop,"totloop",db);
-    ReadField<ErrorPolicy_Igno>(dest.totpoly,"totpoly",db);
-    ReadField<ErrorPolicy_Igno>(dest.subdiv,"subdiv",db);
-    ReadField<ErrorPolicy_Igno>(dest.subdivr,"subdivr",db);
-    ReadField<ErrorPolicy_Igno>(dest.subsurftype,"subsurftype",db);
-    ReadField<ErrorPolicy_Igno>(dest.smoothresh,"smoothresh",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.mface,"*mface",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtface,"*mtface",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.tface,"*tface",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.mvert,"*mvert",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.medge,"*medge",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloop,"*mloop",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopuv,"*mloopuv",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mloopcol,"*mloopcol",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mpoly,"*mpoly",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mtpoly,"*mtpoly",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.dvert,"*dvert",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mcol,"*mcol",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.mat,"**mat",db);
-
-    ReadField<ErrorPolicy_Igno>(dest.vdata, "vdata", db);
-    ReadField<ErrorPolicy_Igno>(dest.edata, "edata", db);
-    ReadField<ErrorPolicy_Igno>(dest.fdata, "fdata", db);
-    ReadField<ErrorPolicy_Igno>(dest.pdata, "pdata", db);
-    ReadField<ErrorPolicy_Warn>(dest.ldata, "ldata", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MDeformVert> (
-    MDeformVert& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.dw,"*dw",db);
-    ReadField<ErrorPolicy_Igno>(dest.totweight,"totweight",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<World> (
-    World& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MLoopCol> (
-    MLoopCol& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Igno>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Igno>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Igno>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Igno>(dest.a,"a",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MVert> (
-    MVert& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray<ErrorPolicy_Fail>(dest.co,"co",db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.no,"no",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    //ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MEdge> (
-    MEdge& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.v1,"v1",db);
-    ReadField<ErrorPolicy_Fail>(dest.v2,"v2",db);
-    ReadField<ErrorPolicy_Igno>(dest.crease,"crease",db);
-    ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MLoopUV> (
-    MLoopUV& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray<ErrorPolicy_Igno>(dest.uv,"uv",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<GroupObject> (
-    GroupObject& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.prev,"*prev",db);
-    ReadFieldPtr<ErrorPolicy_Fail>(dest.next,"*next",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.ob,"*ob",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<ListBase> (
-    ListBase& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.first,"*first",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.last,"*last",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MLoop> (
-    MLoop& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Igno>(dest.v,"v",db);
-    ReadField<ErrorPolicy_Igno>(dest.e,"e",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<ModifierData> (
-    ModifierData& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.next,"*next",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.prev,"*prev",db);
-    ReadField<ErrorPolicy_Igno>(dest.type,"type",db);
-    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
-    ReadFieldArray<ErrorPolicy_Igno>(dest.name,"name",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<ID> (
-    ID& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MCol> (
-    MCol& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.r,"r",db);
-    ReadField<ErrorPolicy_Fail>(dest.g,"g",db);
-    ReadField<ErrorPolicy_Fail>(dest.b,"b",db);
-    ReadField<ErrorPolicy_Fail>(dest.a,"a",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MPoly> (
-    MPoly& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Igno>(dest.loopstart,"loopstart",db);
-    ReadField<ErrorPolicy_Igno>(dest.totloop,"totloop",db);
-    ReadField<ErrorPolicy_Igno>(dest.mat_nr,"mat_nr",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Scene> (
-    Scene& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.camera,"*camera",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.world,"*world",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.basact,"*basact",db);
-    ReadField<ErrorPolicy_Igno>(dest.base,"base",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Library> (
-    Library& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
-    ReadFieldArray<ErrorPolicy_Fail>(dest.filename,"filename",db);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.parent,"*parent",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Tex> (
-    Tex& dest,
-    const FileDatabase& db
-    ) const
-{
-    short temp_short = 0;
-    ReadField<ErrorPolicy_Igno>(temp_short,"imaflag",db);
-    dest.imaflag = static_cast<Assimp::Blender::Tex::ImageFlags>(temp_short);
-    int temp = 0;
-    ReadField<ErrorPolicy_Fail>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Tex::Type>(temp);
-    ReadFieldPtr<ErrorPolicy_Warn>(dest.ima,"*ima",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Camera> (
-    Camera& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    int temp = 0;
-    ReadField<ErrorPolicy_Warn>(temp,"type",db);
-    dest.type = static_cast<Assimp::Blender::Camera::Type>(temp);
-    ReadField<ErrorPolicy_Warn>(temp,"flag",db);
-    dest.flag = static_cast<Assimp::Blender::Camera::Type>(temp);
-    ReadField<ErrorPolicy_Warn>(dest.lens,"lens",db);
-    ReadField<ErrorPolicy_Warn>(dest.sensor_x,"sensor_x",db);
-    ReadField<ErrorPolicy_Igno>(dest.clipsta,"clipsta",db);
-    ReadField<ErrorPolicy_Igno>(dest.clipend,"clipend",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<MirrorModifierData> (
-    MirrorModifierData& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.modifier,"modifier",db);
-    ReadField<ErrorPolicy_Igno>(dest.axis,"axis",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.tolerance,"tolerance",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.mirror_ob,"*mirror_ob",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure :: Convert<Image> (
-    Image& dest,
-    const FileDatabase& db
-    ) const
-{
-
-    ReadField<ErrorPolicy_Fail>(dest.id,"id",db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name,"name",db);
-    ReadField<ErrorPolicy_Igno>(dest.ok,"ok",db);
-    ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Igno>(dest.source,"source",db);
-    ReadField<ErrorPolicy_Igno>(dest.type,"type",db);
-    ReadField<ErrorPolicy_Igno>(dest.pad,"pad",db);
-    ReadField<ErrorPolicy_Igno>(dest.pad1,"pad1",db);
-    ReadField<ErrorPolicy_Igno>(dest.lastframe,"lastframe",db);
-    ReadField<ErrorPolicy_Igno>(dest.tpageflag,"tpageflag",db);
-    ReadField<ErrorPolicy_Igno>(dest.totbind,"totbind",db);
-    ReadField<ErrorPolicy_Igno>(dest.xrep,"xrep",db);
-    ReadField<ErrorPolicy_Igno>(dest.yrep,"yrep",db);
-    ReadField<ErrorPolicy_Igno>(dest.twsta,"twsta",db);
-    ReadField<ErrorPolicy_Igno>(dest.twend,"twend",db);
-    ReadFieldPtr<ErrorPolicy_Igno>(dest.packedfile,"*packedfile",db);
-    ReadField<ErrorPolicy_Igno>(dest.lastupdate,"lastupdate",db);
-    ReadField<ErrorPolicy_Igno>(dest.lastused,"lastused",db);
-    ReadField<ErrorPolicy_Igno>(dest.animspeed,"animspeed",db);
-    ReadField<ErrorPolicy_Igno>(dest.gen_x,"gen_x",db);
-    ReadField<ErrorPolicy_Igno>(dest.gen_y,"gen_y",db);
-    ReadField<ErrorPolicy_Igno>(dest.gen_type,"gen_type",db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure::Convert<CustomData>(
-    CustomData& dest,
-    const FileDatabase& db
-    ) const
-{
-    ReadFieldArray<ErrorPolicy_Warn>(dest.typemap, "typemap", db);
-    ReadField<ErrorPolicy_Warn>(dest.totlayer, "totlayer", db);
-    ReadField<ErrorPolicy_Warn>(dest.maxlayer, "maxlayer", db);
-    ReadField<ErrorPolicy_Warn>(dest.totsize, "totsize", db);
-    ReadFieldPtrVector<ErrorPolicy_Warn>(dest.layers, "*layers", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-template <> void Structure::Convert<CustomDataLayer>(
-    CustomDataLayer& dest,
-    const FileDatabase& db
-    ) const
-{
-    ReadField<ErrorPolicy_Fail>(dest.type, "type", db);
-    ReadField<ErrorPolicy_Fail>(dest.offset, "offset", db);
-    ReadField<ErrorPolicy_Fail>(dest.flag, "flag", db);
-    ReadField<ErrorPolicy_Fail>(dest.active, "active", db);
-    ReadField<ErrorPolicy_Fail>(dest.active_rnd, "active_rnd", db);
-    ReadField<ErrorPolicy_Fail>(dest.active_clone, "active_clone", db);
-    ReadField<ErrorPolicy_Fail>(dest.active_mask, "active_mask", db);
-    ReadField<ErrorPolicy_Fail>(dest.uid, "uid", db);
-    ReadFieldArray<ErrorPolicy_Warn>(dest.name, "name", db);
-    ReadCustomDataPtr<ErrorPolicy_Fail>(dest.data, dest.type, "*data", db);
-
-    db.reader->IncPtr(size);
-}
-
-//--------------------------------------------------------------------------------
-void DNA::RegisterConverters() {
-
-    converters["Object"] = DNA::FactoryPair( &Structure::Allocate<Object>, &Structure::Convert<Object> );
-    converters["Group"] = DNA::FactoryPair( &Structure::Allocate<Group>, &Structure::Convert<Group> );
-    converters["MTex"] = DNA::FactoryPair( &Structure::Allocate<MTex>, &Structure::Convert<MTex> );
-    converters["TFace"] = DNA::FactoryPair( &Structure::Allocate<TFace>, &Structure::Convert<TFace> );
-    converters["SubsurfModifierData"] = DNA::FactoryPair( &Structure::Allocate<SubsurfModifierData>, &Structure::Convert<SubsurfModifierData> );
-    converters["MFace"] = DNA::FactoryPair( &Structure::Allocate<MFace>, &Structure::Convert<MFace> );
-    converters["Lamp"] = DNA::FactoryPair( &Structure::Allocate<Lamp>, &Structure::Convert<Lamp> );
-    converters["MDeformWeight"] = DNA::FactoryPair( &Structure::Allocate<MDeformWeight>, &Structure::Convert<MDeformWeight> );
-    converters["PackedFile"] = DNA::FactoryPair( &Structure::Allocate<PackedFile>, &Structure::Convert<PackedFile> );
-    converters["Base"] = DNA::FactoryPair( &Structure::Allocate<Base>, &Structure::Convert<Base> );
-    converters["MTFace"] = DNA::FactoryPair( &Structure::Allocate<MTFace>, &Structure::Convert<MTFace> );
-    converters["Material"] = DNA::FactoryPair( &Structure::Allocate<Material>, &Structure::Convert<Material> );
-    converters["MTexPoly"] = DNA::FactoryPair( &Structure::Allocate<MTexPoly>, &Structure::Convert<MTexPoly> );
-    converters["Mesh"] = DNA::FactoryPair( &Structure::Allocate<Mesh>, &Structure::Convert<Mesh> );
-    converters["MDeformVert"] = DNA::FactoryPair( &Structure::Allocate<MDeformVert>, &Structure::Convert<MDeformVert> );
-    converters["World"] = DNA::FactoryPair( &Structure::Allocate<World>, &Structure::Convert<World> );
-    converters["MLoopCol"] = DNA::FactoryPair( &Structure::Allocate<MLoopCol>, &Structure::Convert<MLoopCol> );
-    converters["MVert"] = DNA::FactoryPair( &Structure::Allocate<MVert>, &Structure::Convert<MVert> );
-    converters["MEdge"] = DNA::FactoryPair( &Structure::Allocate<MEdge>, &Structure::Convert<MEdge> );
-    converters["MLoopUV"] = DNA::FactoryPair( &Structure::Allocate<MLoopUV>, &Structure::Convert<MLoopUV> );
-    converters["GroupObject"] = DNA::FactoryPair( &Structure::Allocate<GroupObject>, &Structure::Convert<GroupObject> );
-    converters["ListBase"] = DNA::FactoryPair( &Structure::Allocate<ListBase>, &Structure::Convert<ListBase> );
-    converters["MLoop"] = DNA::FactoryPair( &Structure::Allocate<MLoop>, &Structure::Convert<MLoop> );
-    converters["ModifierData"] = DNA::FactoryPair( &Structure::Allocate<ModifierData>, &Structure::Convert<ModifierData> );
-    converters["ID"] = DNA::FactoryPair( &Structure::Allocate<ID>, &Structure::Convert<ID> );
-    converters["MCol"] = DNA::FactoryPair( &Structure::Allocate<MCol>, &Structure::Convert<MCol> );
-    converters["MPoly"] = DNA::FactoryPair( &Structure::Allocate<MPoly>, &Structure::Convert<MPoly> );
-    converters["Scene"] = DNA::FactoryPair( &Structure::Allocate<Scene>, &Structure::Convert<Scene> );
-    converters["Library"] = DNA::FactoryPair( &Structure::Allocate<Library>, &Structure::Convert<Library> );
-    converters["Tex"] = DNA::FactoryPair( &Structure::Allocate<Tex>, &Structure::Convert<Tex> );
-    converters["Camera"] = DNA::FactoryPair( &Structure::Allocate<Camera>, &Structure::Convert<Camera> );
-    converters["MirrorModifierData"] = DNA::FactoryPair( &Structure::Allocate<MirrorModifierData>, &Structure::Convert<MirrorModifierData> );
-    converters["Image"] = DNA::FactoryPair( &Structure::Allocate<Image>, &Structure::Convert<Image> );
-    converters["CustomData"] = DNA::FactoryPair(&Structure::Allocate<CustomData>, &Structure::Convert<CustomData>);
-    converters["CustomDataLayer"] = DNA::FactoryPair(&Structure::Allocate<CustomDataLayer>, &Structure::Convert<CustomDataLayer>);
-}
-
-#endif // ASSIMP_BUILD_NO_BLEND_IMPORTER
-
diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt
index 6afed40f9..e6ed3fa88 100644
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@@ -208,17 +208,17 @@ SET( CApi_SRCS
 SOURCE_GROUP(CApi FILES ${CApi_SRCS})
 
 SET( STEPParser_SRCS
-  Importer/STEPParser/STEPFileReader.h
-  Importer/STEPParser/STEPFileReader.cpp
-  Importer/STEPParser/STEPFileEncoding.cpp
-  Importer/STEPParser/STEPFileEncoding.h
+  AssetLib/STEPParser/STEPFileReader.h
+  AssetLib/STEPParser/STEPFileReader.cpp
+  AssetLib/STEPParser/STEPFileEncoding.cpp
+  AssetLib/STEPParser/STEPFileEncoding.h
 )
 SOURCE_GROUP(STEPParser FILES ${STEPParser_SRCS})
 
 IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
   SET( C4D_SRCS
-    C4D/C4DImporter.cpp
-    C4D/C4DImporter.h
+    AssetLib/C4D/C4DImporter.cpp
+    AssetLib/C4D/C4DImporter.h
   )
   SOURCE_GROUP( C4D FILES ${C4D_SRCS})
 ENDIF ()
@@ -243,7 +243,7 @@ MACRO(ADD_ASSIMP_IMPORTER name)
   IF (ASSIMP_IMPORTER_ENABLED)
     LIST(APPEND ASSIMP_LOADER_SRCS ${ARGN})
     SET(ASSIMP_IMPORTERS_ENABLED "${ASSIMP_IMPORTERS_ENABLED} ${name}")
-    SOURCE_GROUP(${name} FILES ${ARGN})
+    SOURCE_GROUP(AssetLib\\${name} FILES ${ARGN})
   ELSE()
     SET(${name}_SRC "")
     SET(ASSIMP_IMPORTERS_DISABLED "${ASSIMP_IMPORTERS_DISABLED} ${name}")
@@ -276,7 +276,7 @@ if (NOT ASSIMP_NO_EXPORT)
     IF (ASSIMP_EXPORTER_ENABLED)
       SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
       LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
-      SOURCE_GROUP(${name}_EXPORTER FILES ${ARGN})
+      SOURCE_GROUP(AssetLib\\${name} FILES ${ARGN})
     ELSE()
       SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
       add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
@@ -294,157 +294,157 @@ SET(ASSIMP_EXPORTERS_ENABLED "") # list of enabled exporters
 SET(ASSIMP_EXPORTERS_DISABLED "") # disabled exporters list (used to print)
 
 ADD_ASSIMP_IMPORTER( AMF
-  AMF/AMFImporter.hpp
-  AMF/AMFImporter_Macro.hpp
-  AMF/AMFImporter_Node.hpp
-  AMF/AMFImporter.cpp
-  AMF/AMFImporter_Geometry.cpp
-  AMF/AMFImporter_Material.cpp
-  AMF/AMFImporter_Postprocess.cpp
+  AssetLib/AMF/AMFImporter.hpp
+  AssetLib/AMF/AMFImporter_Macro.hpp
+  AssetLib/AMF/AMFImporter_Node.hpp
+  AssetLib/AMF/AMFImporter.cpp
+  AssetLib/AMF/AMFImporter_Geometry.cpp
+  AssetLib/AMF/AMFImporter_Material.cpp
+  AssetLib/AMF/AMFImporter_Postprocess.cpp
 )
 
 ADD_ASSIMP_IMPORTER( 3DS
-  3DS/3DSConverter.cpp
-  3DS/3DSHelper.h
-  3DS/3DSLoader.cpp
-  3DS/3DSLoader.h
+  AssetLib/3DS/3DSConverter.cpp
+  AssetLib/3DS/3DSHelper.h
+  AssetLib/3DS/3DSLoader.cpp
+  AssetLib/3DS/3DSLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( AC
-  AC/ACLoader.cpp
-  AC/ACLoader.h
+  AssetLib/AC/ACLoader.cpp
+  AssetLib/AC/ACLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( ASE
-  ASE/ASELoader.cpp
-  ASE/ASELoader.h
-  ASE/ASEParser.cpp
-  ASE/ASEParser.h
+  AssetLib/ASE/ASELoader.cpp
+  AssetLib/ASE/ASELoader.h
+  AssetLib/ASE/ASEParser.cpp
+  AssetLib/ASE/ASEParser.h
 )
 
 ADD_ASSIMP_IMPORTER( ASSBIN
-  Assbin/AssbinLoader.h
-  Assbin/AssbinLoader.cpp
+  AssetLib/Assbin/AssbinLoader.h
+  AssetLib/Assbin/AssbinLoader.cpp
 )
 
 ADD_ASSIMP_IMPORTER( B3D
-  B3D/B3DImporter.cpp
-  B3D/B3DImporter.h
+  AssetLib/B3D/B3DImporter.cpp
+  AssetLib/B3D/B3DImporter.h
 )
 
 ADD_ASSIMP_IMPORTER( BVH
-  BVH/BVHLoader.cpp
-  BVH/BVHLoader.h
+  AssetLib/BVH/BVHLoader.cpp
+  AssetLib/BVH/BVHLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( COLLADA
-  Collada/ColladaHelper.cpp
-  Collada/ColladaHelper.h
-  Collada/ColladaLoader.cpp
-  Collada/ColladaLoader.h
-  Collada/ColladaParser.cpp
-  Collada/ColladaParser.h
+  AssetLib/Collada/ColladaHelper.cpp
+  AssetLib/Collada/ColladaHelper.h
+  AssetLib/Collada/ColladaLoader.cpp
+  AssetLib/Collada/ColladaLoader.h
+  AssetLib/Collada/ColladaParser.cpp
+  AssetLib/Collada/ColladaParser.h
 )
 
 ADD_ASSIMP_IMPORTER( DXF
-  DXF/DXFLoader.cpp
-  DXF/DXFLoader.h
-  DXF/DXFHelper.h
+  AssetLib/DXF/DXFLoader.cpp
+  AssetLib/DXF/DXFLoader.h
+  AssetLib/DXF/DXFHelper.h
 )
 
 ADD_ASSIMP_IMPORTER( CSM
-  CSM/CSMLoader.cpp
-  CSM/CSMLoader.h
+  AssetLib/CSM/CSMLoader.cpp
+  AssetLib/CSM/CSMLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( HMP
-  HMP/HMPFileData.h
-  HMP/HMPLoader.cpp
-  HMP/HMPLoader.h
-  HMP/HalfLifeFileData.h
+  AssetLib/HMP/HMPFileData.h
+  AssetLib/HMP/HMPLoader.cpp
+  AssetLib/HMP/HMPLoader.h
+  AssetLib/HMP/HalfLifeFileData.h
 )
 
 ADD_ASSIMP_IMPORTER( IRRMESH
-  Irr/IRRMeshLoader.cpp
-  Irr/IRRMeshLoader.h
-  Irr/IRRShared.cpp
-  Irr/IRRShared.h
+  AssetLib/Irr/IRRMeshLoader.cpp
+  AssetLib/Irr/IRRMeshLoader.h
+  AssetLib/Irr/IRRShared.cpp
+  AssetLib/Irr/IRRShared.h
 )
 
 ADD_ASSIMP_IMPORTER( IRR
-  Irr/IRRLoader.cpp
-  Irr/IRRLoader.h
-  Irr/IRRShared.cpp
-  Irr/IRRShared.h
+  AssetLib/Irr/IRRLoader.cpp
+  AssetLib/Irr/IRRLoader.h
+  AssetLib/Irr/IRRShared.cpp
+  AssetLib/Irr/IRRShared.h
 )
 
 ADD_ASSIMP_IMPORTER( LWO
-  LWO/LWOAnimation.cpp
-  LWO/LWOAnimation.h
-  LWO/LWOBLoader.cpp
-  LWO/LWOFileData.h
-  LWO/LWOLoader.cpp
-  LWO/LWOLoader.h
-  LWO/LWOMaterial.cpp
+  AssetLib/LWO/LWOAnimation.cpp
+  AssetLib/LWO/LWOAnimation.h
+  AssetLib/LWO/LWOBLoader.cpp
+  AssetLib/LWO/LWOFileData.h
+  AssetLib/LWO/LWOLoader.cpp
+  AssetLib/LWO/LWOLoader.h
+  AssetLib/LWO/LWOMaterial.cpp
 )
 
 ADD_ASSIMP_IMPORTER( LWS
-  LWS/LWSLoader.cpp
-  LWS/LWSLoader.h
+  AssetLib/LWS/LWSLoader.cpp
+  AssetLib/LWS/LWSLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( M3D
-  M3D/M3DMaterials.h
-  M3D/M3DImporter.h
-  M3D/M3DImporter.cpp
-  M3D/M3DWrapper.h
-  M3D/M3DWrapper.cpp
-  M3D/m3d.h
+  AssetLib/M3D/M3DMaterials.h
+  AssetLib/M3D/M3DImporter.h
+  AssetLib/M3D/M3DImporter.cpp
+  AssetLib/M3D/M3DWrapper.h
+  AssetLib/M3D/M3DWrapper.cpp
+  AssetLib/M3D/m3d.h
 )
 
 ADD_ASSIMP_IMPORTER( MD2
-  MD2/MD2FileData.h
-  MD2/MD2Loader.cpp
-  MD2/MD2Loader.h
-  MD2/MD2NormalTable.h
+  AssetLib/MD2/MD2FileData.h
+  AssetLib/MD2/MD2Loader.cpp
+  AssetLib/MD2/MD2Loader.h
+  AssetLib/MD2/MD2NormalTable.h
 )
 
 ADD_ASSIMP_IMPORTER( MD3
-  MD3/MD3FileData.h
-  MD3/MD3Loader.cpp
-  MD3/MD3Loader.h
+  AssetLib/MD3/MD3FileData.h
+  AssetLib/MD3/MD3Loader.cpp
+  AssetLib/MD3/MD3Loader.h
 )
 
 ADD_ASSIMP_IMPORTER( MD5
-  MD5/MD5Loader.cpp
-  MD5/MD5Loader.h
-  MD5/MD5Parser.cpp
-  MD5/MD5Parser.h
+  AssetLib/MD5/MD5Loader.cpp
+  AssetLib/MD5/MD5Loader.h
+  AssetLib/MD5/MD5Parser.cpp
+  AssetLib/MD5/MD5Parser.h
 )
 
 ADD_ASSIMP_IMPORTER( MDC
-  MDC/MDCFileData.h
-  MDC/MDCLoader.cpp
-  MDC/MDCLoader.h
-  MDC/MDCNormalTable.h
+  AssetLib/MDC/MDCFileData.h
+  AssetLib/MDC/MDCLoader.cpp
+  AssetLib/MDC/MDCLoader.h
+  AssetLib/MDC/MDCNormalTable.h
 )
 
 ADD_ASSIMP_IMPORTER( MDL
-  MDL/MDLDefaultColorMap.h
-  MDL/MDLFileData.h
-  MDL/MDLLoader.cpp
-  MDL/MDLLoader.h
-  MDL/MDLMaterialLoader.cpp
-  MDL/HalfLife/HalfLifeMDLBaseHeader.h
-  MDL/HalfLife/HL1FileData.h
-  MDL/HalfLife/HL1MDLLoader.cpp
-  MDL/HalfLife/HL1MDLLoader.h
-  MDL/HalfLife/HL1ImportDefinitions.h
-  MDL/HalfLife/HL1ImportSettings.h
-  MDL/HalfLife/HL1MeshTrivert.h
-  MDL/HalfLife/LogFunctions.h
-  MDL/HalfLife/UniqueNameGenerator.cpp
-  MDL/HalfLife/UniqueNameGenerator.h
+  AssetLib/MDL/MDLDefaultColorMap.h
+  AssetLib/MDL/MDLFileData.h
+  AssetLib/MDL/MDLLoader.cpp
+  AssetLib/MDL/MDLLoader.h
+  AssetLib/MDL/MDLMaterialLoader.cpp
+  AssetLib/MDL/HalfLife/HalfLifeMDLBaseHeader.h
+  AssetLib/MDL/HalfLife/HL1FileData.h
+  AssetLib/MDL/HalfLife/HL1MDLLoader.cpp
+  AssetLib/MDL/HalfLife/HL1MDLLoader.h
+  AssetLib/MDL/HalfLife/HL1ImportDefinitions.h
+  AssetLib/MDL/HalfLife/HL1ImportSettings.h
+  AssetLib/MDL/HalfLife/HL1MeshTrivert.h
+  AssetLib/MDL/HalfLife/LogFunctions.h
+  AssetLib/MDL/HalfLife/UniqueNameGenerator.cpp
+  AssetLib/MDL/HalfLife/UniqueNameGenerator.h
 )
 
 SET( MaterialSystem_SRCS
@@ -454,102 +454,102 @@ SET( MaterialSystem_SRCS
 SOURCE_GROUP( MaterialSystem FILES ${MaterialSystem_SRCS})
 
 ADD_ASSIMP_IMPORTER( NFF
-  NFF/NFFLoader.cpp
-  NFF/NFFLoader.h
+  AssetLib/NFF/NFFLoader.cpp
+  AssetLib/NFF/NFFLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( NDO
-  NDO/NDOLoader.cpp
-  NDO/NDOLoader.h
+  AssetLib/NDO/NDOLoader.cpp
+  AssetLib/NDO/NDOLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( OFF
-  OFF/OFFLoader.cpp
-  OFF/OFFLoader.h
+  AssetLib/OFF/OFFLoader.cpp
+  AssetLib/OFF/OFFLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( OBJ
-  Obj/ObjFileData.h
-  Obj/ObjFileImporter.cpp
-  Obj/ObjFileImporter.h
-  Obj/ObjFileMtlImporter.cpp
-  Obj/ObjFileMtlImporter.h
-  Obj/ObjFileParser.cpp
-  Obj/ObjFileParser.h
-  Obj/ObjTools.h
+  AssetLib/Obj/ObjFileData.h
+  AssetLib/Obj/ObjFileImporter.cpp
+  AssetLib/Obj/ObjFileImporter.h
+  AssetLib/Obj/ObjFileMtlImporter.cpp
+  AssetLib/Obj/ObjFileMtlImporter.h
+  AssetLib/Obj/ObjFileParser.cpp
+  AssetLib/Obj/ObjFileParser.h
+  AssetLib/Obj/ObjTools.h
 )
 
 ADD_ASSIMP_IMPORTER( OGRE
-  Ogre/OgreImporter.h
-  Ogre/OgreStructs.h
-  Ogre/OgreParsingUtils.h
-  Ogre/OgreBinarySerializer.h
-  Ogre/OgreXmlSerializer.h
-  Ogre/OgreImporter.cpp
-  Ogre/OgreStructs.cpp
-  Ogre/OgreBinarySerializer.cpp
-  Ogre/OgreXmlSerializer.cpp
-  Ogre/OgreMaterial.cpp
+  AssetLib/Ogre/OgreImporter.h
+  AssetLib/Ogre/OgreStructs.h
+  AssetLib/Ogre/OgreParsingUtils.h
+  AssetLib/Ogre/OgreBinarySerializer.h
+  AssetLib/Ogre/OgreXmlSerializer.h
+  AssetLib/Ogre/OgreImporter.cpp
+  AssetLib/Ogre/OgreStructs.cpp
+  AssetLib/Ogre/OgreBinarySerializer.cpp
+  AssetLib/Ogre/OgreXmlSerializer.cpp
+  AssetLib/Ogre/OgreMaterial.cpp
 )
 
 ADD_ASSIMP_IMPORTER( OPENGEX
-  OpenGEX/OpenGEXImporter.cpp
-  OpenGEX/OpenGEXImporter.h
-  OpenGEX/OpenGEXStructs.h
+  AssetLib/OpenGEX/OpenGEXImporter.cpp
+  AssetLib/OpenGEX/OpenGEXImporter.h
+  AssetLib/OpenGEX/OpenGEXStructs.h
 )
 
 ADD_ASSIMP_IMPORTER( PLY
-  Ply/PlyLoader.cpp
-  Ply/PlyLoader.h
-  Ply/PlyParser.cpp
-  Ply/PlyParser.h
+  AssetLib/Ply/PlyLoader.cpp
+  AssetLib/Ply/PlyLoader.h
+  AssetLib/Ply/PlyParser.cpp
+  AssetLib/Ply/PlyParser.h
 )
 
 ADD_ASSIMP_IMPORTER( MS3D
-  MS3D/MS3DLoader.cpp
-  MS3D/MS3DLoader.h
+  AssetLib/MS3D/MS3DLoader.cpp
+  AssetLib/MS3D/MS3DLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( COB
-  COB/COBLoader.cpp
-  COB/COBLoader.h
-  COB/COBScene.h
+  AssetLib/COB/COBLoader.cpp
+  AssetLib/COB/COBLoader.h
+  AssetLib/COB/COBScene.h
 )
 
 ADD_ASSIMP_IMPORTER( BLEND
-  Blender/BlenderLoader.cpp
-  Blender/BlenderLoader.h
-  Blender/BlenderDNA.cpp
-  Blender/BlenderDNA.h
-  Blender/BlenderDNA.inl
-  Blender/BlenderScene.cpp
-  Blender/BlenderScene.h
-  Blender/BlenderSceneGen.h
-  Blender/BlenderIntermediate.h
-  Blender/BlenderModifier.h
-  Blender/BlenderModifier.cpp
-  Blender/BlenderBMesh.h
-  Blender/BlenderBMesh.cpp
-  Blender/BlenderTessellator.h
-  Blender/BlenderTessellator.cpp
-  Blender/BlenderCustomData.h
-  Blender/BlenderCustomData.cpp
+  AssetLib/Blender/BlenderLoader.cpp
+  AssetLib/Blender/BlenderLoader.h
+  AssetLib/Blender/BlenderDNA.cpp
+  AssetLib/Blender/BlenderDNA.h
+  AssetLib/Blender/BlenderDNA.inl
+  AssetLib/Blender/BlenderScene.cpp
+  AssetLib/Blender/BlenderScene.h
+  AssetLib/Blender/BlenderSceneGen.h
+  AssetLib/Blender/BlenderIntermediate.h
+  AssetLib/Blender/BlenderModifier.h
+  AssetLib/Blender/BlenderModifier.cpp
+  AssetLib/Blender/BlenderBMesh.h
+  AssetLib/Blender/BlenderBMesh.cpp
+  AssetLib/Blender/BlenderTessellator.h
+  AssetLib/Blender/BlenderTessellator.cpp
+  AssetLib/Blender/BlenderCustomData.h
+  AssetLib/Blender/BlenderCustomData.cpp
 )
 
 ADD_ASSIMP_IMPORTER( IFC
-  Importer/IFC/IFCLoader.cpp
-  Importer/IFC/IFCLoader.h
-  Importer/IFC/IFCReaderGen1_2x3.cpp
-  Importer/IFC/IFCReaderGen2_2x3.cpp
-  Importer/IFC/IFCReaderGen_2x3.h
-  Importer/IFC/IFCUtil.h
-  Importer/IFC/IFCUtil.cpp
-  Importer/IFC/IFCGeometry.cpp
-  Importer/IFC/IFCMaterial.cpp
-  Importer/IFC/IFCProfile.cpp
-  Importer/IFC/IFCCurve.cpp
-  Importer/IFC/IFCBoolean.cpp
-  Importer/IFC/IFCOpenings.cpp
+  AssetLib/IFC/IFCLoader.cpp
+  AssetLib/IFC/IFCLoader.h
+  AssetLib/IFC/IFCReaderGen1_2x3.cpp
+  AssetLib/IFC/IFCReaderGen2_2x3.cpp
+  AssetLib/IFC/IFCReaderGen_2x3.h
+  AssetLib/IFC/IFCUtil.h
+  AssetLib/IFC/IFCUtil.cpp
+  AssetLib/IFC/IFCGeometry.cpp
+  AssetLib/IFC/IFCMaterial.cpp
+  AssetLib/IFC/IFCProfile.cpp
+  AssetLib/IFC/IFCCurve.cpp
+  AssetLib/IFC/IFCBoolean.cpp
+  AssetLib/IFC/IFCOpenings.cpp
 )
 
 if (ASSIMP_BUILD_IFC_IMPORTER)
@@ -561,117 +561,117 @@ if (ASSIMP_BUILD_IFC_IMPORTER)
 endif ()
 
 ADD_ASSIMP_IMPORTER( XGL
-  XGL/XGLLoader.cpp
-  XGL/XGLLoader.h
+  AssetLib/XGL/XGLLoader.cpp
+  AssetLib/XGL/XGLLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( FBX
-  FBX/FBXImporter.cpp
-  FBX/FBXCompileConfig.h
-  FBX/FBXImporter.h
-  FBX/FBXParser.cpp
-  FBX/FBXParser.h
-  FBX/FBXTokenizer.cpp
-  FBX/FBXTokenizer.h
-  FBX/FBXImportSettings.h
-  FBX/FBXConverter.h
-  FBX/FBXConverter.cpp
-  FBX/FBXUtil.h
-  FBX/FBXUtil.cpp
-  FBX/FBXDocument.h
-  FBX/FBXDocument.cpp
-  FBX/FBXProperties.h
-  FBX/FBXProperties.cpp
-  FBX/FBXMeshGeometry.h
-  FBX/FBXMeshGeometry.cpp
-  FBX/FBXMaterial.cpp
-  FBX/FBXModel.cpp
-  FBX/FBXAnimation.cpp
-  FBX/FBXNodeAttribute.cpp
-  FBX/FBXDeformer.cpp
-  FBX/FBXBinaryTokenizer.cpp
-  FBX/FBXDocumentUtil.cpp
-  FBX/FBXCommon.h
+  AssetLib/FBX/FBXImporter.cpp
+  AssetLib/FBX/FBXCompileConfig.h
+  AssetLib/FBX/FBXImporter.h
+  AssetLib/FBX/FBXParser.cpp
+  AssetLib/FBX/FBXParser.h
+  AssetLib/FBX/FBXTokenizer.cpp
+  AssetLib/FBX/FBXTokenizer.h
+  AssetLib/FBX/FBXImportSettings.h
+  AssetLib/FBX/FBXConverter.h
+  AssetLib/FBX/FBXConverter.cpp
+  AssetLib/FBX/FBXUtil.h
+  AssetLib/FBX/FBXUtil.cpp
+  AssetLib/FBX/FBXDocument.h
+  AssetLib/FBX/FBXDocument.cpp
+  AssetLib/FBX/FBXProperties.h
+  AssetLib/FBX/FBXProperties.cpp
+  AssetLib/FBX/FBXMeshGeometry.h
+  AssetLib/FBX/FBXMeshGeometry.cpp
+  AssetLib/FBX/FBXMaterial.cpp
+  AssetLib/FBX/FBXModel.cpp
+  AssetLib/FBX/FBXAnimation.cpp
+  AssetLib/FBX/FBXNodeAttribute.cpp
+  AssetLib/FBX/FBXDeformer.cpp
+  AssetLib/FBX/FBXBinaryTokenizer.cpp
+  AssetLib/FBX/FBXDocumentUtil.cpp
+  AssetLib/FBX/FBXCommon.h
 )
 
 if (NOT ASSIMP_NO_EXPORT)
 
   ADD_ASSIMP_EXPORTER( OBJ
-    Obj/ObjExporter.h
-    Obj/ObjExporter.cpp)
+    AssetLib/Obj/ObjExporter.h
+    AssetLib/Obj/ObjExporter.cpp)
 
   ADD_ASSIMP_EXPORTER( OPENGEX
-    OpenGEX/OpenGEXExporter.cpp
-    OpenGEX/OpenGEXExporter.h)
+    AssetLib/OpenGEX/OpenGEXExporter.cpp
+    AssetLib/OpenGEX/OpenGEXExporter.h)
 
   ADD_ASSIMP_EXPORTER( PLY
-    Ply/PlyExporter.cpp
-    Ply/PlyExporter.h)
+    AssetLib/Ply/PlyExporter.cpp
+    AssetLib/Ply/PlyExporter.h)
 
   ADD_ASSIMP_EXPORTER( 3DS
-    3DS/3DSExporter.h
-    3DS/3DSExporter.cpp)
+    AssetLib/3DS/3DSExporter.h
+    AssetLib/3DS/3DSExporter.cpp)
 
   ADD_ASSIMP_EXPORTER( ASSBIN
-    Assbin/AssbinExporter.h
-    Assbin/AssbinExporter.cpp
-    Assbin/AssbinFileWriter.h
-    Assbin/AssbinFileWriter.cpp)
+    AssetLib/Assbin/AssbinExporter.h
+    AssetLib/Assbin/AssbinExporter.cpp
+    AssetLib/Assbin/AssbinFileWriter.h
+    AssetLib/Assbin/AssbinFileWriter.cpp)
 
   ADD_ASSIMP_EXPORTER( ASSXML
-    Assxml/AssxmlExporter.h
-    Assxml/AssxmlExporter.cpp
-    Assxml/AssxmlFileWriter.h
-    Assxml/AssxmlFileWriter.cpp)
+    AssetLib/Assxml/AssxmlExporter.h
+    AssetLib/Assxml/AssxmlExporter.cpp
+    AssetLib/Assxml/AssxmlFileWriter.h
+    AssetLib/Assxml/AssxmlFileWriter.cpp)
 
   ADD_ASSIMP_EXPORTER(M3D
-    M3D/M3DExporter.h
-    M3D/M3DExporter.cpp)
+    AssetLib/M3D/M3DExporter.h
+    AssetLib/M3D/M3DExporter.cpp)
 
   ADD_ASSIMP_EXPORTER(COLLADA
-    Collada/ColladaExporter.h
-    Collada/ColladaExporter.cpp)
+    AssetLib/Collada/ColladaExporter.h
+    AssetLib/Collada/ColladaExporter.cpp)
 
   ADD_ASSIMP_EXPORTER( FBX
-    FBX/FBXExporter.h
-    FBX/FBXExporter.cpp
-    FBX/FBXExportNode.h
-    FBX/FBXExportNode.cpp
-    FBX/FBXExportProperty.h
-    FBX/FBXExportProperty.cpp)
+    AssetLib/FBX/FBXExporter.h
+    AssetLib/FBX/FBXExporter.cpp
+    AssetLib/FBX/FBXExportNode.h
+    AssetLib/FBX/FBXExportNode.cpp
+    AssetLib/FBX/FBXExportProperty.h
+    AssetLib/FBX/FBXExportProperty.cpp)
 
   ADD_ASSIMP_EXPORTER( STL
-    STL/STLExporter.h
-    STL/STLExporter.cpp)
+    AssetLib/STL/STLExporter.h
+    AssetLib/STL/STLExporter.cpp)
 
   ADD_ASSIMP_EXPORTER( X
-    X/XFileExporter.h
-    X/XFileExporter.cpp)
+    AssetLib/X/XFileExporter.h
+    AssetLib/X/XFileExporter.cpp)
 
   ADD_ASSIMP_EXPORTER( X3D
-    X3D/X3DExporter.cpp
-    X3D/X3DExporter.hpp)
+    AssetLib/X3D/X3DExporter.cpp
+    AssetLib/X3D/X3DExporter.hpp)
 
   ADD_ASSIMP_EXPORTER( GLTF
-    glTF/glTFExporter.h
-    glTF/glTFExporter.cpp
-    glTF2/glTF2Exporter.h
-    glTF2/glTF2Exporter.cpp)
+    AssetLib/glTF/glTFExporter.h
+    AssetLib/glTF/glTFExporter.cpp
+    AssetLib/glTF2/glTF2Exporter.h
+    AssetLib/glTF2/glTF2Exporter.cpp)
 
   ADD_ASSIMP_EXPORTER( 3MF
-    3MF/D3MFExporter.h
-    3MF/D3MFExporter.cpp)
+    AssetLib/3MF/D3MFExporter.h
+    AssetLib/3MF/D3MFExporter.cpp)
 
   ADD_ASSIMP_EXPORTER( ASSJSON
-    Assjson/cencode.c
-    Assjson/cencode.h
-    Assjson/json_exporter.cpp
-    Assjson/mesh_splitter.cpp
-    Assjson/mesh_splitter.h)
+    AssetLib/Assjson/cencode.c
+    AssetLib/Assjson/cencode.h
+    AssetLib/Assjson/json_exporter.cpp
+    AssetLib/Assjson/mesh_splitter.cpp
+    AssetLib/Assjson/mesh_splitter.h)
 
   ADD_ASSIMP_EXPORTER( STEP
-    Step/StepExporter.h
-    Step/StepExporter.cpp)
+    AssetLib/Step/StepExporter.h
+    AssetLib/Step/StepExporter.cpp)
 
 endif()
 
@@ -745,109 +745,109 @@ SET( IrrXML_SRCS ${HEADER_PATH}/irrXMLWrapper.h )
 SOURCE_GROUP( IrrXML FILES ${IrrXML_SRCS})
 
 ADD_ASSIMP_IMPORTER( Q3D
-  Q3D/Q3DLoader.cpp
-  Q3D/Q3DLoader.h
+  AssetLib/Q3D/Q3DLoader.cpp
+  AssetLib/Q3D/Q3DLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( Q3BSP
-  Q3BSP/Q3BSPFileData.h
-  Q3BSP/Q3BSPFileParser.h
-  Q3BSP/Q3BSPFileParser.cpp
-  Q3BSP/Q3BSPFileImporter.h
-  Q3BSP/Q3BSPFileImporter.cpp
+  AssetLib/Q3BSP/Q3BSPFileData.h
+  AssetLib/Q3BSP/Q3BSPFileParser.h
+  AssetLib/Q3BSP/Q3BSPFileParser.cpp
+  AssetLib/Q3BSP/Q3BSPFileImporter.h
+  AssetLib/Q3BSP/Q3BSPFileImporter.cpp
 )
 
 ADD_ASSIMP_IMPORTER( RAW
-  Raw/RawLoader.cpp
-  Raw/RawLoader.h
+  AssetLib/Raw/RawLoader.cpp
+  AssetLib/Raw/RawLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( SIB
-  SIB/SIBImporter.cpp
-  SIB/SIBImporter.h
+  AssetLib/SIB/SIBImporter.cpp
+  AssetLib/SIB/SIBImporter.h
 )
 
 ADD_ASSIMP_IMPORTER( SMD
-  SMD/SMDLoader.cpp
-  SMD/SMDLoader.h
+  AssetLib/SMD/SMDLoader.cpp
+  AssetLib/SMD/SMDLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( STL
-  STL/STLLoader.cpp
-  STL/STLLoader.h
+  AssetLib/STL/STLLoader.cpp
+  AssetLib/STL/STLLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( TERRAGEN
-  Terragen/TerragenLoader.cpp
-  Terragen/TerragenLoader.h
+  AssetLib/Terragen/TerragenLoader.cpp
+  AssetLib/Terragen/TerragenLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( 3D
-  Unreal/UnrealLoader.cpp
-  Unreal/UnrealLoader.h
+  AssetLib/Unreal/UnrealLoader.cpp
+  AssetLib/Unreal/UnrealLoader.h
 )
 
 ADD_ASSIMP_IMPORTER( X
-  X/XFileHelper.h
-  X/XFileImporter.cpp
-  X/XFileImporter.h
-  X/XFileParser.cpp
-  X/XFileParser.h
+  AssetLib/X/XFileHelper.h
+  AssetLib/X/XFileImporter.cpp
+  AssetLib/X/XFileImporter.h
+  AssetLib/X/XFileParser.cpp
+  AssetLib/X/XFileParser.h
 )
 
 ADD_ASSIMP_IMPORTER( X3D
-  X3D/X3DImporter.cpp
-  X3D/X3DImporter.hpp
-  X3D/X3DImporter_Geometry2D.cpp
-  X3D/X3DImporter_Geometry3D.cpp
-  X3D/X3DImporter_Group.cpp
-  X3D/X3DImporter_Light.cpp
-  X3D/X3DImporter_Macro.hpp
-  X3D/X3DImporter_Metadata.cpp
-  X3D/X3DImporter_Networking.cpp
-  X3D/X3DImporter_Node.hpp
-  X3D/X3DImporter_Postprocess.cpp
-  X3D/X3DImporter_Rendering.cpp
-  X3D/X3DImporter_Shape.cpp
-  X3D/X3DImporter_Texturing.cpp
-  X3D/FIReader.hpp
-  X3D/FIReader.cpp
-  X3D/X3DVocabulary.cpp
+  AssetLib/X3D/X3DImporter.cpp
+  AssetLib/X3D/X3DImporter.hpp
+  AssetLib/X3D/X3DImporter_Geometry2D.cpp
+  AssetLib/X3D/X3DImporter_Geometry3D.cpp
+  AssetLib/X3D/X3DImporter_Group.cpp
+  AssetLib/X3D/X3DImporter_Light.cpp
+  AssetLib/X3D/X3DImporter_Macro.hpp
+  AssetLib/X3D/X3DImporter_Metadata.cpp
+  AssetLib/X3D/X3DImporter_Networking.cpp
+  AssetLib/X3D/X3DImporter_Node.hpp
+  AssetLib/X3D/X3DImporter_Postprocess.cpp
+  AssetLib/X3D/X3DImporter_Rendering.cpp
+  AssetLib/X3D/X3DImporter_Shape.cpp
+  AssetLib/X3D/X3DImporter_Texturing.cpp
+  AssetLib/X3D/FIReader.hpp
+  AssetLib/X3D/FIReader.cpp
+  AssetLib/X3D/X3DVocabulary.cpp
 )
 
 ADD_ASSIMP_IMPORTER( GLTF
-  glTF/glTFCommon.h
-  glTF/glTFCommon.cpp
-  glTF/glTFAsset.h
-  glTF/glTFAsset.inl
-  glTF/glTFAssetWriter.h
-  glTF/glTFAssetWriter.inl
-  glTF/glTFImporter.cpp
-  glTF/glTFImporter.h
-  glTF2/glTF2Asset.h
-  glTF2/glTF2Asset.inl
-  glTF2/glTF2AssetWriter.h
-  glTF2/glTF2AssetWriter.inl
-  glTF2/glTF2Importer.cpp
-  glTF2/glTF2Importer.h
+  AssetLib/glTF/glTFCommon.h
+  AssetLib/glTF/glTFCommon.cpp
+  AssetLib/glTF/glTFAsset.h
+  AssetLib/glTF/glTFAsset.inl
+  AssetLib/glTF/glTFAssetWriter.h
+  AssetLib/glTF/glTFAssetWriter.inl
+  AssetLib/glTF/glTFImporter.cpp
+  AssetLib/glTF/glTFImporter.h
+  AssetLib/glTF2/glTF2Asset.h
+  AssetLib/glTF2/glTF2Asset.inl
+  AssetLib/glTF2/glTF2AssetWriter.h
+  AssetLib/glTF2/glTF2AssetWriter.inl
+  AssetLib/glTF2/glTF2Importer.cpp
+  AssetLib/glTF2/glTF2Importer.h
 )
 
 ADD_ASSIMP_IMPORTER( 3MF
-  3MF/D3MFImporter.h
-  3MF/D3MFImporter.cpp
-  3MF/D3MFOpcPackage.h
-  3MF/D3MFOpcPackage.cpp
-  3MF/3MFXmlTags.h
+  AssetLib/3MF/D3MFImporter.h
+  AssetLib/3MF/D3MFImporter.cpp
+  AssetLib/3MF/D3MFOpcPackage.h
+  AssetLib/3MF/D3MFOpcPackage.cpp
+  AssetLib/3MF/3MFXmlTags.h
 )
 
 ADD_ASSIMP_IMPORTER( MMD
-  MMD/MMDCpp14.h
-  MMD/MMDImporter.cpp
-  MMD/MMDImporter.h
-  MMD/MMDPmdParser.h
-  MMD/MMDPmxParser.h
-  MMD/MMDPmxParser.cpp
-  MMD/MMDVmdParser.h
+  AssetLib/MMD/MMDCpp14.h
+  AssetLib/MMD/MMDImporter.cpp
+  AssetLib/MMD/MMDImporter.h
+  AssetLib/MMD/MMDPmdParser.h
+  AssetLib/MMD/MMDPmxParser.h
+  AssetLib/MMD/MMDPmxParser.cpp
+  AssetLib/MMD/MMDVmdParser.h
 )
 
 # Workaround for issue #2406 - force problematic large file to be optimized to prevent string table overflow error
@@ -1211,8 +1211,8 @@ endif()
 if (${CMAKE_SYSTEM_NAME} MATCHES "WindowsStore")
     target_compile_definitions(assimp PUBLIC WindowsStore)
     TARGET_LINK_LIBRARIES(assimp advapi32)
-    #set(WindowsStore TRUE)
 endif()
+
 SET_TARGET_PROPERTIES( assimp PROPERTIES
   VERSION ${ASSIMP_VERSION}
   SOVERSION ${ASSIMP_SOVERSION} # use full version
diff --git a/code/Collada/ColladaExporter.cpp b/code/Collada/ColladaExporter.cpp
deleted file mode 100644
index e27e7aa90..000000000
--- a/code/Collada/ColladaExporter.cpp
+++ /dev/null
@@ -1,1708 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the
-following conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_EXPORT
-#ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-
-#include "ColladaExporter.h"
-#include <assimp/Bitmap.h>
-#include <assimp/commonMetaData.h>
-#include <assimp/MathFunctions.h>
-#include <assimp/fast_atof.h>
-#include <assimp/SceneCombiner.h>
-#include <assimp/StringUtils.h>
-#include <assimp/XMLTools.h>
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/IOSystem.hpp>
-#include <assimp/Exporter.hpp>
-#include <assimp/scene.h>
-
-#include <assimp/Exceptional.h>
-
-#include <memory>
-#include <ctime>
-#include <set>
-#include <vector>
-#include <iostream>
-
-using namespace Assimp;
-
-namespace Assimp {
-
-// ------------------------------------------------------------------------------------------------
-// Worker function for exporting a scene to Collada. Prototyped and registered in Exporter.cpp
-void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* /*pProperties*/) {
-    std::string path = DefaultIOSystem::absolutePath(std::string(pFile));
-    std::string file = DefaultIOSystem::completeBaseName(std::string(pFile));
-
-    // invoke the exporter
-    ColladaExporter iDoTheExportThing( pScene, pIOSystem, path, file);
-    
-    if (iDoTheExportThing.mOutput.fail()) {
-        throw DeadlyExportError("output data creation failed. Most likely the file became too large: " + std::string(pFile));
-    }
-
-    // we're still here - export successfully completed. Write result to the given IOSYstem
-    std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
-    if(outfile == NULL) {
-        throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
-    }
-
-    // XXX maybe use a small wrapper around IOStream that behaves like std::stringstream in order to avoid the extra copy.
-    outfile->Write( iDoTheExportThing.mOutput.str().c_str(), static_cast<size_t>(iDoTheExportThing.mOutput.tellp()),1);
-}
-
-} // end of namespace Assimp
-
-// ------------------------------------------------------------------------------------------------
-// Encodes a string into a valid XML ID using the xsd:ID schema qualifications.
-static const std::string XMLIDEncode(const std::string& name) {
-    const char XML_ID_CHARS[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_-.";
-    const unsigned int XML_ID_CHARS_COUNT = sizeof(XML_ID_CHARS) / sizeof(char);
-
-    if (name.length() == 0) {
-        return name;
-    }
-
-    std::stringstream idEncoded;
-
-    // xsd:ID must start with letter or underscore
-    if (!((name[0] >= 'A' && name[0] <= 'z') || name[0] == '_')) {
-        idEncoded << '_';
-    }
-
-    for (std::string::const_iterator it = name.begin(); it != name.end(); ++it) {
-        // xsd:ID can only contain letters, digits, underscores, hyphens and periods
-        if (strchr(XML_ID_CHARS, *it) != nullptr) {
-            idEncoded << *it;
-        } else {
-            // Select placeholder character based on invalid character to prevent name collisions 
-            idEncoded << XML_ID_CHARS[(*it) % XML_ID_CHARS_COUNT];
-        }
-    }
-
-    return idEncoded.str();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Constructor for a specific scene to export
-ColladaExporter::ColladaExporter( const aiScene* pScene, IOSystem* pIOSystem, const std::string& path, const std::string& file) 
-: mIOSystem(pIOSystem)
-, mPath(path)
-, mFile(file) {
-    // make sure that all formatting happens using the standard, C locale and not the user's current locale
-    mOutput.imbue( std::locale("C") );
-    mOutput.precision(ASSIMP_AI_REAL_TEXT_PRECISION);
-
-    mScene = pScene;
-    mSceneOwned = false;
-
-    // set up strings
-    endstr = "\n";
-
-    // start writing the file
-    WriteFile();
-}
-
-// ------------------------------------------------------------------------------------------------
-// Destructor
-ColladaExporter::~ColladaExporter() {
-    if ( mSceneOwned ) {
-        delete mScene;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Starts writing the contents
-void ColladaExporter::WriteFile() {
-    // write the DTD
-    mOutput << "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\" ?>" << endstr;
-    // COLLADA element start
-    mOutput << "<COLLADA xmlns=\"http://www.collada.org/2005/11/COLLADASchema\" version=\"1.4.1\">" << endstr;
-    PushTag();
-
-    WriteTextures();
-    WriteHeader();
-
-    WriteCamerasLibrary();
-    WriteLightsLibrary();
-    WriteMaterials();
-    WriteGeometryLibrary();
-    WriteControllerLibrary();
-
-    WriteSceneLibrary();
-	
-	// customized, Writes the animation library
-	WriteAnimationsLibrary();
-
-    // useless Collada fu at the end, just in case we haven't had enough indirections, yet.
-    mOutput << startstr << "<scene>" << endstr;
-    PushTag();
-    mOutput << startstr << "<instance_visual_scene url=\"#" + XMLIDEncode(mScene->mRootNode->mName.C_Str()) + "\" />" << endstr;
-    PopTag();
-    mOutput << startstr << "</scene>" << endstr;
-    PopTag();
-    mOutput << "</COLLADA>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the asset header
-void ColladaExporter::WriteHeader() {
-    static const ai_real epsilon = Math::getEpsilon<ai_real>();
-    static const aiQuaternion x_rot(aiMatrix3x3(
-        0, -1,  0,
-        1,  0,  0,
-        0,  0,  1));
-    static const aiQuaternion y_rot(aiMatrix3x3(
-        1,  0,  0,
-        0,  1,  0,
-        0,  0,  1));
-    static const aiQuaternion z_rot(aiMatrix3x3(
-        1,  0,  0,
-        0,  0,  1,
-        0, -1,  0));
-
-    static const unsigned int date_nb_chars = 20;
-    char date_str[date_nb_chars];
-    std::time_t date = std::time(NULL);
-    std::strftime(date_str, date_nb_chars, "%Y-%m-%dT%H:%M:%S", std::localtime(&date));
-
-    aiVector3D scaling;
-    aiQuaternion rotation;
-    aiVector3D position;
-    mScene->mRootNode->mTransformation.Decompose(scaling, rotation, position);
-    rotation.Normalize();
-
-    bool add_root_node = false;
-
-    ai_real scale = 1.0;
-    if(std::abs(scaling.x - scaling.y) <= epsilon && std::abs(scaling.x - scaling.z) <= epsilon && std::abs(scaling.y - scaling.z) <= epsilon) {
-        scale = (ai_real) ((((double) scaling.x) + ((double) scaling.y) + ((double) scaling.z)) / 3.0);
-    } else {
-        add_root_node = true;
-    }
-
-    std::string up_axis = "Y_UP";
-    if(rotation.Equal(x_rot, epsilon)) {
-        up_axis = "X_UP";
-    } else if(rotation.Equal(y_rot, epsilon)) {
-        up_axis = "Y_UP";
-    } else if(rotation.Equal(z_rot, epsilon)) {
-        up_axis = "Z_UP";
-    } else {
-        add_root_node = true;
-    }
-
-    if(! position.Equal(aiVector3D(0, 0, 0))) {
-        add_root_node = true;
-    }
-
-    if(mScene->mRootNode->mNumChildren == 0) {
-        add_root_node = true;
-    }
-
-    if(add_root_node) {
-        aiScene* scene;
-        SceneCombiner::CopyScene(&scene, mScene);
-
-        aiNode* root = new aiNode("Scene");
-
-        root->mNumChildren = 1;
-        root->mChildren = new aiNode*[root->mNumChildren];
-
-        root->mChildren[0] = scene->mRootNode;
-        scene->mRootNode->mParent = root;
-        scene->mRootNode = root;
-
-        mScene = scene;
-        mSceneOwned = true;
-
-        up_axis = "Y_UP";
-        scale = 1.0;
-    }
-
-    mOutput << startstr << "<asset>" << endstr;
-    PushTag();
-    mOutput << startstr << "<contributor>" << endstr;
-    PushTag();
-
-    // If no Scene metadata, use root node metadata
-    aiMetadata* meta = mScene->mMetaData;
-    if (nullptr == meta) {
-        meta = mScene->mRootNode->mMetaData;
-    }
-
-    aiString value;
-    if (!meta || !meta->Get("Author", value)) {
-        mOutput << startstr << "<author>" << "Assimp" << "</author>" << endstr;
-    } else {
-        mOutput << startstr << "<author>" << XMLEscape(value.C_Str()) << "</author>" << endstr;
-    }
-
-    if (nullptr == meta || !meta->Get(AI_METADATA_SOURCE_GENERATOR, value)) {
-        mOutput << startstr << "<authoring_tool>" << "Assimp Exporter" << "</authoring_tool>" << endstr;
-    } else {
-        mOutput << startstr << "<authoring_tool>" << XMLEscape(value.C_Str()) << "</authoring_tool>" << endstr;
-    }
-
-    if (meta) {
-        if (meta->Get("Comments", value)) {
-            mOutput << startstr << "<comments>" << XMLEscape(value.C_Str()) << "</comments>" << endstr;
-        }
-        if (meta->Get(AI_METADATA_SOURCE_COPYRIGHT, value)) {
-            mOutput << startstr << "<copyright>" << XMLEscape(value.C_Str()) << "</copyright>" << endstr;
-        }
-        if (meta->Get("SourceData", value)) {
-            mOutput << startstr << "<source_data>" << XMLEscape(value.C_Str()) << "</source_data>" << endstr;
-        }
-    }
-
-    PopTag();
-    mOutput << startstr << "</contributor>" << endstr;
-
-    if (nullptr == meta || !meta->Get("Created", value)) {
-        mOutput << startstr << "<created>" << date_str << "</created>" << endstr;
-    } else {
-        mOutput << startstr << "<created>" << XMLEscape(value.C_Str()) << "</created>" << endstr;
-    }
-
-    // Modified date is always the date saved
-    mOutput << startstr << "<modified>" << date_str << "</modified>" << endstr;
-
-    if (meta) {
-        if (meta->Get("Keywords", value)) {
-            mOutput << startstr << "<keywords>" << XMLEscape(value.C_Str()) << "</keywords>" << endstr;
-        }
-        if (meta->Get("Revision", value)) {
-            mOutput << startstr << "<revision>" << XMLEscape(value.C_Str()) << "</revision>" << endstr;
-        }
-        if (meta->Get("Subject", value)) {
-            mOutput << startstr << "<subject>" << XMLEscape(value.C_Str()) << "</subject>" << endstr;
-        }
-        if (meta->Get("Title", value)) {
-            mOutput << startstr << "<title>" << XMLEscape(value.C_Str()) << "</title>" << endstr;
-        }
-    }
-
-    mOutput << startstr << "<unit name=\"meter\" meter=\"" << scale << "\" />" << endstr;
-    mOutput << startstr << "<up_axis>" << up_axis << "</up_axis>" << endstr;
-    PopTag();
-    mOutput << startstr << "</asset>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Write the embedded textures
-void ColladaExporter::WriteTextures() {
-    static const unsigned int buffer_size = 1024;
-    char str[buffer_size];
-
-    if (mScene->HasTextures()) {
-        for(unsigned int i = 0; i < mScene->mNumTextures; i++) {
-            // It would be great to be able to create a directory in portable standard C++, but it's not the case,
-            // so we just write the textures in the current directory.
-
-            aiTexture* texture = mScene->mTextures[i];
-            if ( nullptr == texture ) {
-                continue;
-            }
-
-            ASSIMP_itoa10(str, buffer_size, i + 1);
-
-            std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char*) texture->achFormatHint);
-
-            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + mIOSystem->getOsSeparator() + name, "wb"));
-            if(outfile == NULL) {
-                throw DeadlyExportError("could not open output texture file: " + mPath + name);
-            }
-
-            if(texture->mHeight == 0) {
-                outfile->Write((void*) texture->pcData, texture->mWidth, 1);
-            } else {
-                Bitmap::Save(texture, outfile.get());
-            }
-
-            outfile->Flush();
-
-            textures.insert(std::make_pair(i, name));
-        }
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Write the embedded textures
-void ColladaExporter::WriteCamerasLibrary() {
-    if(mScene->HasCameras()) {
-
-        mOutput << startstr << "<library_cameras>" << endstr;
-        PushTag();
-
-        for( size_t a = 0; a < mScene->mNumCameras; ++a)
-            WriteCamera( a);
-
-        PopTag();
-        mOutput << startstr << "</library_cameras>" << endstr;
-
-    }
-}
-
-void ColladaExporter::WriteCamera(size_t pIndex){
-
-    const aiCamera *cam = mScene->mCameras[pIndex];
-    const std::string cameraName = XMLEscape(cam->mName.C_Str());
-    const std::string cameraId = XMLIDEncode(cam->mName.C_Str());
-
-    mOutput << startstr << "<camera id=\"" << cameraId << "-camera\" name=\"" << cameraName << "\" >" << endstr;
-    PushTag();
-    mOutput << startstr << "<optics>" << endstr;
-    PushTag();
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    //assimp doesn't support the import of orthographic cameras! se we write
-    //always perspective
-    mOutput << startstr << "<perspective>" << endstr;
-    PushTag();
-    mOutput << startstr << "<xfov sid=\"xfov\">"<<
-                                AI_RAD_TO_DEG(cam->mHorizontalFOV)
-                        <<"</xfov>" << endstr;
-    mOutput << startstr << "<aspect_ratio>"
-                        <<      cam->mAspect
-                        << "</aspect_ratio>" << endstr;
-    mOutput << startstr << "<znear sid=\"znear\">"
-                        <<      cam->mClipPlaneNear
-                        <<  "</znear>" << endstr;
-    mOutput << startstr << "<zfar sid=\"zfar\">"
-                        <<      cam->mClipPlaneFar
-                        << "</zfar>" << endstr;
-    PopTag();
-    mOutput << startstr << "</perspective>" << endstr;
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-    PopTag();
-    mOutput << startstr << "</optics>" << endstr;
-    PopTag();
-    mOutput << startstr << "</camera>" << endstr;
-
-}
-
-
-// ------------------------------------------------------------------------------------------------
-// Write the embedded textures
-void ColladaExporter::WriteLightsLibrary() {
-    if(mScene->HasLights()) {
-
-        mOutput << startstr << "<library_lights>" << endstr;
-        PushTag();
-
-        for( size_t a = 0; a < mScene->mNumLights; ++a)
-            WriteLight( a);
-
-        PopTag();
-        mOutput << startstr << "</library_lights>" << endstr;
-
-    }
-}
-
-void ColladaExporter::WriteLight(size_t pIndex){
-
-    const aiLight *light = mScene->mLights[pIndex];
-    const std::string lightName = XMLEscape(light->mName.C_Str());
-    const std::string lightId = XMLIDEncode(light->mName.C_Str());
-
-    mOutput << startstr << "<light id=\"" << lightId << "-light\" name=\""
-            << lightName << "\" >" << endstr;
-    PushTag();
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    switch(light->mType){
-        case aiLightSource_AMBIENT:
-            WriteAmbienttLight(light);
-            break;
-        case aiLightSource_DIRECTIONAL:
-            WriteDirectionalLight(light);
-            break;
-        case aiLightSource_POINT:
-            WritePointLight(light);
-            break;
-        case aiLightSource_SPOT:
-            WriteSpotLight(light);
-            break;
-        case aiLightSource_AREA:
-        case aiLightSource_UNDEFINED:
-        case _aiLightSource_Force32Bit:
-            break;
-    }
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</light>" << endstr;
-
-}
-
-void ColladaExporter::WritePointLight(const aiLight *const light){
-    const aiColor3D &color=  light->mColorDiffuse;
-    mOutput << startstr << "<point>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-    mOutput << startstr << "<constant_attenuation>"
-                            << light->mAttenuationConstant
-                        <<"</constant_attenuation>" << endstr;
-    mOutput << startstr << "<linear_attenuation>"
-                            << light->mAttenuationLinear
-                        <<"</linear_attenuation>" << endstr;
-    mOutput << startstr << "<quadratic_attenuation>"
-                            << light->mAttenuationQuadratic
-                        <<"</quadratic_attenuation>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</point>" << endstr;
-
-}
-
-void ColladaExporter::WriteDirectionalLight(const aiLight *const light){
-    const aiColor3D &color=  light->mColorDiffuse;
-    mOutput << startstr << "<directional>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</directional>" << endstr;
-
-}
-
-void ColladaExporter::WriteSpotLight(const aiLight *const light){
-
-    const aiColor3D &color=  light->mColorDiffuse;
-    mOutput << startstr << "<spot>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-    mOutput << startstr << "<constant_attenuation>"
-                                << light->mAttenuationConstant
-                            <<"</constant_attenuation>" << endstr;
-    mOutput << startstr << "<linear_attenuation>"
-                            << light->mAttenuationLinear
-                        <<"</linear_attenuation>" << endstr;
-    mOutput << startstr << "<quadratic_attenuation>"
-                            << light->mAttenuationQuadratic
-                        <<"</quadratic_attenuation>" << endstr;
-    /*
-    out->mAngleOuterCone = AI_DEG_TO_RAD (std::acos(std::pow(0.1f,1.f/srcLight->mFalloffExponent))+
-                            srcLight->mFalloffAngle);
-    */
-
-    const ai_real fallOffAngle = AI_RAD_TO_DEG(light->mAngleInnerCone);
-    mOutput << startstr <<"<falloff_angle sid=\"fall_off_angle\">"
-                                << fallOffAngle
-                        <<"</falloff_angle>" << endstr;
-    double temp = light->mAngleOuterCone-light->mAngleInnerCone;
-
-    temp = std::cos(temp);
-    temp = std::log(temp)/std::log(0.1);
-    temp = 1/temp;
-    mOutput << startstr << "<falloff_exponent sid=\"fall_off_exponent\">"
-                            << temp
-                        <<"</falloff_exponent>" << endstr;
-
-
-    PopTag();
-    mOutput << startstr << "</spot>" << endstr;
-
-}
-
-void ColladaExporter::WriteAmbienttLight(const aiLight *const light){
-
-    const aiColor3D &color=  light->mColorAmbient;
-    mOutput << startstr << "<ambient>" << endstr;
-    PushTag();
-    mOutput << startstr << "<color sid=\"color\">"
-                            << color.r<<" "<<color.g<<" "<<color.b
-                        <<"</color>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</ambient>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reads a single surface entry from the given material keys
-void ColladaExporter::ReadMaterialSurface( Surface& poSurface, const aiMaterial* pSrcMat, 
-                                          aiTextureType pTexture, const char* pKey, size_t pType, size_t pIndex) {
-  if( pSrcMat->GetTextureCount( pTexture) > 0 ) {
-    aiString texfile;
-    unsigned int uvChannel = 0;
-    pSrcMat->GetTexture( pTexture, 0, &texfile, NULL, &uvChannel);
-
-    std::string index_str(texfile.C_Str());
-
-    if(index_str.size() != 0 && index_str[0] == '*') {
-        unsigned int index;
-
-        index_str = index_str.substr(1, std::string::npos);
-
-        try {
-            index = (unsigned int) strtoul10_64(index_str.c_str());
-        } catch(std::exception& error) {
-            throw DeadlyExportError(error.what());
-        }
-
-        std::map<unsigned int, std::string>::const_iterator name = textures.find(index);
-
-        if(name != textures.end()) {
-            poSurface.texture = name->second;
-        } else {
-            throw DeadlyExportError("could not find embedded texture at index " + index_str);
-        }
-    } else {
-        poSurface.texture = texfile.C_Str();
-    }
-
-    poSurface.channel = uvChannel;
-    poSurface.exist = true;
-  } else {
-    if( pKey )
-      poSurface.exist = pSrcMat->Get( pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Reimplementation of isalnum(,C locale), because AppVeyor does not see standard version.
-static bool isalnum_C(char c) {
-  return ( nullptr != strchr("0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz",c) );
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes an image entry for the given surface
-void ColladaExporter::WriteImageEntry( const Surface& pSurface, const std::string& pNameAdd) {
-  if( !pSurface.texture.empty() )
-  {
-    mOutput << startstr << "<image id=\"" << XMLIDEncode(pNameAdd) << "\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<init_from>";
-
-    // URL encode image file name first, then XML encode on top
-    std::stringstream imageUrlEncoded;
-    for( std::string::const_iterator it = pSurface.texture.begin(); it != pSurface.texture.end(); ++it )
-    {
-      if( isalnum_C( (unsigned char) *it) || *it == ':' || *it == '_' || *it == '-' || *it == '.' || *it == '/' || *it == '\\' )
-        imageUrlEncoded << *it;
-      else
-        imageUrlEncoded << '%' << std::hex << size_t( (unsigned char) *it) << std::dec;
-    }
-    mOutput << XMLEscape(imageUrlEncoded.str());
-    mOutput << "</init_from>" << endstr;
-    PopTag();
-    mOutput << startstr << "</image>" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a color-or-texture entry into an effect definition
-void ColladaExporter::WriteTextureColorEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pImageName)
-{
-  if(pSurface.exist) {
-    mOutput << startstr << "<" << pTypeName << ">" << endstr;
-    PushTag();
-    if( pSurface.texture.empty() )
-    {
-      mOutput << startstr << "<color sid=\"" << pTypeName << "\">" << pSurface.color.r << "   " << pSurface.color.g << "   " << pSurface.color.b << "   " << pSurface.color.a << "</color>" << endstr;
-    }
-    else
-    {
-      mOutput << startstr << "<texture texture=\"" << XMLIDEncode(pImageName) << "\" texcoord=\"CHANNEL" << pSurface.channel << "\" />" << endstr;
-    }
-    PopTag();
-    mOutput << startstr << "</" << pTypeName << ">" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the two parameters necessary for referencing a texture in an effect entry
-void ColladaExporter::WriteTextureParamEntry( const Surface& pSurface, const std::string& pTypeName, const std::string& pMatName)
-{
-  // if surface is a texture, write out the sampler and the surface parameters necessary to reference the texture
-  if( !pSurface.texture.empty() )
-  {
-    mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<surface type=\"2D\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<init_from>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-image</init_from>" << endstr;
-    PopTag();
-    mOutput << startstr << "</surface>" << endstr;
-    PopTag();
-    mOutput << startstr << "</newparam>" << endstr;
-
-    mOutput << startstr << "<newparam sid=\"" << XMLIDEncode(pMatName) << "-" << pTypeName << "-sampler\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<sampler2D>" << endstr;
-    PushTag();
-    mOutput << startstr << "<source>" << XMLIDEncode(pMatName) << "-" << pTypeName << "-surface</source>" << endstr;
-    PopTag();
-    mOutput << startstr << "</sampler2D>" << endstr;
-    PopTag();
-    mOutput << startstr << "</newparam>" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a scalar property
-void ColladaExporter::WriteFloatEntry( const Property& pProperty, const std::string& pTypeName)
-{
-    if(pProperty.exist) {
-        mOutput << startstr << "<" << pTypeName << ">" << endstr;
-        PushTag();
-        mOutput << startstr << "<float sid=\"" << pTypeName << "\">" << pProperty.value << "</float>" << endstr;
-        PopTag();
-        mOutput << startstr << "</" << pTypeName << ">" << endstr;
-    }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the material setup
-void ColladaExporter::WriteMaterials()
-{
-  materials.resize( mScene->mNumMaterials);
-
-  /// collect all materials from the scene
-  size_t numTextures = 0;
-  for( size_t a = 0; a < mScene->mNumMaterials; ++a )
-  {
-    const aiMaterial* mat = mScene->mMaterials[a];
-
-    aiString name;
-    if( mat->Get( AI_MATKEY_NAME, name) != aiReturn_SUCCESS ) {
-      name = "mat";
-      materials[a].name = std::string( "m") + to_string(a) + name.C_Str();
-    } else {
-      // try to use the material's name if no other material has already taken it, else append #
-      std::string testName = name.C_Str();
-      size_t materialCountWithThisName = 0;
-      for( size_t i = 0; i < a; i ++ ) {
-        if( materials[i].name == testName ) {
-          materialCountWithThisName ++;
-        }
-      }
-      if( materialCountWithThisName == 0 ) {
-        materials[a].name = name.C_Str();
-      } else {
-        materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);
-      }
-    }
-
-    aiShadingMode shading = aiShadingMode_Flat;
-    materials[a].shading_model = "phong";
-    if(mat->Get( AI_MATKEY_SHADING_MODEL, shading) == aiReturn_SUCCESS) {
-        if(shading == aiShadingMode_Phong) {
-            materials[a].shading_model = "phong";
-        } else if(shading == aiShadingMode_Blinn) {
-            materials[a].shading_model = "blinn";
-        } else if(shading == aiShadingMode_NoShading) {
-            materials[a].shading_model = "constant";
-        } else if(shading == aiShadingMode_Gouraud) {
-            materials[a].shading_model = "lambert";
-        }
-    }
-
-    ReadMaterialSurface( materials[a].ambient, mat, aiTextureType_AMBIENT, AI_MATKEY_COLOR_AMBIENT);
-    if( !materials[a].ambient.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].diffuse, mat, aiTextureType_DIFFUSE, AI_MATKEY_COLOR_DIFFUSE);
-    if( !materials[a].diffuse.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].specular, mat, aiTextureType_SPECULAR, AI_MATKEY_COLOR_SPECULAR);
-    if( !materials[a].specular.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].emissive, mat, aiTextureType_EMISSIVE, AI_MATKEY_COLOR_EMISSIVE);
-    if( !materials[a].emissive.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].reflective, mat, aiTextureType_REFLECTION, AI_MATKEY_COLOR_REFLECTIVE);
-    if( !materials[a].reflective.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].transparent, mat, aiTextureType_OPACITY, AI_MATKEY_COLOR_TRANSPARENT);
-    if( !materials[a].transparent.texture.empty() ) numTextures++;
-    ReadMaterialSurface( materials[a].normal, mat, aiTextureType_NORMALS, NULL, 0, 0);
-    if( !materials[a].normal.texture.empty() ) numTextures++;
-
-    materials[a].shininess.exist = mat->Get( AI_MATKEY_SHININESS, materials[a].shininess.value) == aiReturn_SUCCESS;
-    materials[a].transparency.exist = mat->Get( AI_MATKEY_OPACITY, materials[a].transparency.value) == aiReturn_SUCCESS;
-    materials[a].index_refraction.exist = mat->Get( AI_MATKEY_REFRACTI, materials[a].index_refraction.value) == aiReturn_SUCCESS;
-  }
-
-  // output textures if present
-  if( numTextures > 0 )
-  {
-    mOutput << startstr << "<library_images>" << endstr;
-    PushTag();
-    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
-    {
-      const Material& mat = *it;
-      WriteImageEntry( mat.ambient, mat.name + "-ambient-image");
-      WriteImageEntry( mat.diffuse, mat.name + "-diffuse-image");
-      WriteImageEntry( mat.specular, mat.name + "-specular-image");
-      WriteImageEntry( mat.emissive, mat.name + "-emission-image");
-      WriteImageEntry( mat.reflective, mat.name + "-reflective-image");
-      WriteImageEntry( mat.transparent, mat.name + "-transparent-image");
-      WriteImageEntry( mat.normal, mat.name + "-normal-image");
-    }
-    PopTag();
-    mOutput << startstr << "</library_images>" << endstr;
-  }
-
-  // output effects - those are the actual carriers of information
-  if( !materials.empty() )
-  {
-    mOutput << startstr << "<library_effects>" << endstr;
-    PushTag();
-    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
-    {
-      const Material& mat = *it;
-      // this is so ridiculous it must be right
-      mOutput << startstr << "<effect id=\"" << XMLIDEncode(mat.name) << "-fx\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
-      PushTag();
-      mOutput << startstr << "<profile_COMMON>" << endstr;
-      PushTag();
-
-      // write sampler- and surface params for the texture entries
-      WriteTextureParamEntry( mat.emissive, "emission", mat.name);
-      WriteTextureParamEntry( mat.ambient, "ambient", mat.name);
-      WriteTextureParamEntry( mat.diffuse, "diffuse", mat.name);
-      WriteTextureParamEntry( mat.specular, "specular", mat.name);
-      WriteTextureParamEntry( mat.reflective, "reflective", mat.name);
-      WriteTextureParamEntry( mat.transparent, "transparent", mat.name);
-      WriteTextureParamEntry( mat.normal, "normal", mat.name);
-
-      mOutput << startstr << "<technique sid=\"standard\">" << endstr;
-      PushTag();
-      mOutput << startstr << "<" << mat.shading_model << ">" << endstr;
-      PushTag();
-
-      WriteTextureColorEntry( mat.emissive, "emission", mat.name + "-emission-sampler");
-      WriteTextureColorEntry( mat.ambient, "ambient", mat.name + "-ambient-sampler");
-      WriteTextureColorEntry( mat.diffuse, "diffuse", mat.name + "-diffuse-sampler");
-      WriteTextureColorEntry( mat.specular, "specular", mat.name + "-specular-sampler");
-      WriteFloatEntry(mat.shininess, "shininess");
-      WriteTextureColorEntry( mat.reflective, "reflective", mat.name + "-reflective-sampler");
-      WriteTextureColorEntry( mat.transparent, "transparent", mat.name + "-transparent-sampler");
-      WriteFloatEntry(mat.transparency, "transparency");
-      WriteFloatEntry(mat.index_refraction, "index_of_refraction");
-
-      if(! mat.normal.texture.empty()) {
-        WriteTextureColorEntry( mat.normal, "bump", mat.name + "-normal-sampler");
-      }
-
-      PopTag();
-      mOutput << startstr << "</" << mat.shading_model << ">" << endstr;
-      PopTag();
-      mOutput << startstr << "</technique>" << endstr;
-      PopTag();
-      mOutput << startstr << "</profile_COMMON>" << endstr;
-      PopTag();
-      mOutput << startstr << "</effect>" << endstr;
-    }
-    PopTag();
-    mOutput << startstr << "</library_effects>" << endstr;
-
-    // write materials - they're just effect references
-    mOutput << startstr << "<library_materials>" << endstr;
-    PushTag();
-    for( std::vector<Material>::const_iterator it = materials.begin(); it != materials.end(); ++it )
-    {
-      const Material& mat = *it;
-      mOutput << startstr << "<material id=\"" << XMLIDEncode(mat.name) << "\" name=\"" << XMLEscape(mat.name) << "\">" << endstr;
-      PushTag();
-      mOutput << startstr << "<instance_effect url=\"#" << XMLIDEncode(mat.name) << "-fx\"/>" << endstr;
-      PopTag();
-      mOutput << startstr << "</material>" << endstr;
-    }
-    PopTag();
-    mOutput << startstr << "</library_materials>" << endstr;
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the controller library
-void ColladaExporter::WriteControllerLibrary()
-{
-    mOutput << startstr << "<library_controllers>" << endstr;
-    PushTag();
-    
-    for( size_t a = 0; a < mScene->mNumMeshes; ++a) {
-        WriteController( a);
-    }
-
-    PopTag();
-    mOutput << startstr << "</library_controllers>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a skin controller of the given mesh
-void ColladaExporter::WriteController( size_t pIndex)
-{
-    const aiMesh* mesh = mScene->mMeshes[pIndex];
-    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
-    const std::string idstrEscaped = XMLIDEncode(idstr);
-
-    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-        return;
-
-    if ( mesh->mNumBones == 0 )
-        return;
-
-    mOutput << startstr << "<controller id=\"" << idstrEscaped << "-skin\" ";
-    mOutput << "name=\"skinCluster" << pIndex << "\">"<< endstr;
-    PushTag();
-
-    mOutput << startstr << "<skin source=\"#" << idstrEscaped << "\">" << endstr;
-    PushTag();
-
-    // bind pose matrix
-    mOutput << startstr << "<bind_shape_matrix>" << endstr;
-    PushTag();
-
-    // I think it is identity in general cases.
-    aiMatrix4x4 mat;
-    mOutput << startstr << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << endstr;
-    mOutput << startstr << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << endstr;
-    mOutput << startstr << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << endstr;
-    mOutput << startstr << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4 << endstr;
-
-    PopTag();
-    mOutput << startstr << "</bind_shape_matrix>" << endstr;
-
-    mOutput << startstr << "<source id=\"" << idstrEscaped << "-skin-joints\" name=\"" << idstrEscaped << "-skin-joints\">" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<Name_array id=\"" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\">";
-
-    for( size_t i = 0; i < mesh->mNumBones; ++i )
-        mOutput << XMLIDEncode(mesh->mBones[i]->mName.C_Str()) << " ";
-
-    mOutput << "</Name_array>" << endstr;
-
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    
-    mOutput << startstr << "<accessor source=\"#" << idstrEscaped << "-skin-joints-array\" count=\"" << mesh->mNumBones << "\" stride=\"" << 1 << "\">" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<param name=\"JOINT\" type=\"Name\"></param>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</accessor>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</source>" << endstr;
-
-    std::vector<ai_real> bind_poses;
-    bind_poses.reserve(mesh->mNumBones * 16);
-    for(unsigned int i = 0; i < mesh->mNumBones; ++i)
-        for( unsigned int j = 0; j < 4; ++j)
-            bind_poses.insert(bind_poses.end(), mesh->mBones[i]->mOffsetMatrix[j], mesh->mBones[i]->mOffsetMatrix[j] + 4);
-
-    WriteFloatArray( idstr + "-skin-bind_poses", FloatType_Mat4x4, (const ai_real*) bind_poses.data(), bind_poses.size() / 16);
-
-    bind_poses.clear();
-    
-    std::vector<ai_real> skin_weights;
-    skin_weights.reserve(mesh->mNumVertices * mesh->mNumBones);
-    for( size_t i = 0; i < mesh->mNumBones; ++i)
-        for( size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
-            skin_weights.push_back(mesh->mBones[i]->mWeights[j].mWeight);
-
-    WriteFloatArray( idstr + "-skin-weights", FloatType_Weight, (const ai_real*) skin_weights.data(), skin_weights.size());
-
-    skin_weights.clear();
-
-    mOutput << startstr << "<joints>" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\"></input>" << endstr;
-    mOutput << startstr << "<input semantic=\"INV_BIND_MATRIX\" source=\"#" << idstrEscaped << "-skin-bind_poses\"></input>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</joints>" << endstr;
-
-    mOutput << startstr << "<vertex_weights count=\"" << mesh->mNumVertices << "\">" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<input semantic=\"JOINT\" source=\"#" << idstrEscaped << "-skin-joints\" offset=\"0\"></input>" << endstr;
-    mOutput << startstr << "<input semantic=\"WEIGHT\" source=\"#" << idstrEscaped << "-skin-weights\" offset=\"1\"></input>" << endstr;
-
-    mOutput << startstr << "<vcount>";
-
-    std::vector<ai_uint> num_influences(mesh->mNumVertices, (ai_uint)0);
-    for( size_t i = 0; i < mesh->mNumBones; ++i)
-        for( size_t j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
-            ++num_influences[mesh->mBones[i]->mWeights[j].mVertexId];
-
-    for( size_t i = 0; i < mesh->mNumVertices; ++i)
-        mOutput << num_influences[i] << " ";
-
-    mOutput << "</vcount>" << endstr;
-
-    mOutput << startstr << "<v>";
-
-    ai_uint joint_weight_indices_length = 0;
-    std::vector<ai_uint> accum_influences;
-    accum_influences.reserve(num_influences.size());
-    for( size_t i = 0; i < num_influences.size(); ++i)
-    {
-        accum_influences.push_back(joint_weight_indices_length);
-        joint_weight_indices_length += num_influences[i];
-    }
-
-    ai_uint weight_index = 0;
-    std::vector<ai_int> joint_weight_indices(2 * joint_weight_indices_length, (ai_int)-1);
-    for( unsigned int i = 0; i < mesh->mNumBones; ++i)
-        for( unsigned j = 0; j < mesh->mBones[i]->mNumWeights; ++j)
-        {
-            unsigned int vId = mesh->mBones[i]->mWeights[j].mVertexId;
-            for( ai_uint k = 0; k < num_influences[vId]; ++k)
-            {
-                if (joint_weight_indices[2 * (accum_influences[vId] + k)] == -1)
-                {
-                    joint_weight_indices[2 * (accum_influences[vId] + k)] = i;
-                    joint_weight_indices[2 * (accum_influences[vId] + k) + 1] = weight_index;
-                    break;
-                }
-            }
-            ++weight_index;
-        }
-
-    for( size_t i = 0; i < joint_weight_indices.size(); ++i)
-        mOutput << joint_weight_indices[i] << " ";
-
-    num_influences.clear();
-    accum_influences.clear();
-    joint_weight_indices.clear();
-
-    mOutput << "</v>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</vertex_weights>" << endstr;
-
-    PopTag();
-    mOutput << startstr << "</skin>" << endstr;
-    
-    PopTag();
-    mOutput << startstr << "</controller>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the geometry library
-void ColladaExporter::WriteGeometryLibrary()
-{
-    mOutput << startstr << "<library_geometries>" << endstr;
-    PushTag();
-
-    for( size_t a = 0; a < mScene->mNumMeshes; ++a)
-        WriteGeometry( a);
-
-    PopTag();
-    mOutput << startstr << "</library_geometries>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the given mesh
-void ColladaExporter::WriteGeometry( size_t pIndex)
-{
-    const aiMesh* mesh = mScene->mMeshes[pIndex];
-    const std::string idstr = mesh->mName.length == 0 ? GetMeshId(pIndex) : mesh->mName.C_Str();
-    const std::string geometryName = XMLEscape(idstr);
-    const std::string geometryId = XMLIDEncode(idstr);
-
-    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-        return;
-
-    // opening tag
-    mOutput << startstr << "<geometry id=\"" << geometryId << "\" name=\"" << geometryName << "\" >" << endstr;
-    PushTag();
-
-    mOutput << startstr << "<mesh>" << endstr;
-    PushTag();
-
-    // Positions
-    WriteFloatArray( idstr + "-positions", FloatType_Vector, (ai_real*) mesh->mVertices, mesh->mNumVertices);
-    // Normals, if any
-    if( mesh->HasNormals() )
-        WriteFloatArray( idstr + "-normals", FloatType_Vector, (ai_real*) mesh->mNormals, mesh->mNumVertices);
-
-    // texture coords
-    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
-    {
-        if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-        {
-            WriteFloatArray( idstr + "-tex" + to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
-                (ai_real*) mesh->mTextureCoords[a], mesh->mNumVertices);
-        }
-    }
-
-    // vertex colors
-    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
-    {
-        if( mesh->HasVertexColors(static_cast<unsigned int>(a)) )
-            WriteFloatArray( idstr + "-color" + to_string(a), FloatType_Color, (ai_real*) mesh->mColors[a], mesh->mNumVertices);
-    }
-
-    // assemble vertex structure
-    // Only write input for POSITION since we will write other as shared inputs in polygon definition
-    mOutput << startstr << "<vertices id=\"" << geometryId << "-vertices" << "\">" << endstr;
-    PushTag();
-    mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << geometryId << "-positions\" />" << endstr;
-    PopTag();
-    mOutput << startstr << "</vertices>" << endstr;
-
-    // count the number of lines, triangles and polygon meshes
-    int countLines = 0;
-    int countPoly = 0;
-    for( size_t a = 0; a < mesh->mNumFaces; ++a )
-    {
-        if (mesh->mFaces[a].mNumIndices == 2) countLines++;
-        else if (mesh->mFaces[a].mNumIndices >= 3) countPoly++;
-    }
-
-    // lines
-    if (countLines)
-    {
-        mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
-        if( mesh->HasNormals() )
-            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-        {
-            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
-        {
-            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
-                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-
-        mOutput << startstr << "<p>";
-        for( size_t a = 0; a < mesh->mNumFaces; ++a )
-        {
-            const aiFace& face = mesh->mFaces[a];
-            if (face.mNumIndices != 2) continue;
-            for( size_t b = 0; b < face.mNumIndices; ++b )
-                mOutput << face.mIndices[b] << " ";
-        }
-        mOutput << "</p>" << endstr;
-        PopTag();
-        mOutput << startstr << "</lines>" << endstr;
-    }
-
-    // triangle - don't use it, because compatibility problems
-
-    // polygons
-    if (countPoly)
-    {
-        mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
-        PushTag();
-        mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << geometryId << "-vertices\" />" << endstr;
-        if( mesh->HasNormals() )
-            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << geometryId << "-normals\" />" << endstr;
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-        {
-            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << geometryId << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
-        {
-            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << geometryId << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
-        }
-
-        mOutput << startstr << "<vcount>";
-        for( size_t a = 0; a < mesh->mNumFaces; ++a )
-        {
-            if (mesh->mFaces[a].mNumIndices < 3) continue;
-            mOutput << mesh->mFaces[a].mNumIndices << " ";
-        }
-        mOutput << "</vcount>" << endstr;
-
-        mOutput << startstr << "<p>";
-        for( size_t a = 0; a < mesh->mNumFaces; ++a )
-        {
-            const aiFace& face = mesh->mFaces[a];
-            if (face.mNumIndices < 3) continue;
-            for( size_t b = 0; b < face.mNumIndices; ++b )
-                mOutput << face.mIndices[b] << " ";
-        }
-        mOutput << "</p>" << endstr;
-        PopTag();
-        mOutput << startstr << "</polylist>" << endstr;
-    }
-
-    // closing tags
-    PopTag();
-    mOutput << startstr << "</mesh>" << endstr;
-    PopTag();
-    mOutput << startstr << "</geometry>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes a float array of the given type
-void ColladaExporter::WriteFloatArray( const std::string& pIdString, FloatDataType pType, const ai_real* pData, size_t pElementCount)
-{
-    size_t floatsPerElement = 0;
-    switch( pType )
-    {
-        case FloatType_Vector: floatsPerElement = 3; break;
-        case FloatType_TexCoord2: floatsPerElement = 2; break;
-        case FloatType_TexCoord3: floatsPerElement = 3; break;
-        case FloatType_Color: floatsPerElement = 3; break;
-        case FloatType_Mat4x4: floatsPerElement = 16; break;
-        case FloatType_Weight: floatsPerElement = 1; break;
-		case FloatType_Time: floatsPerElement = 1; break;
-        default:
-            return;
-    }
-
-    std::string arrayId = XMLIDEncode(pIdString) + "-array";
-
-    mOutput << startstr << "<source id=\"" << XMLIDEncode(pIdString) << "\" name=\"" << XMLEscape(pIdString) << "\">" << endstr;
-    PushTag();
-
-    // source array
-    mOutput << startstr << "<float_array id=\"" << arrayId << "\" count=\"" << pElementCount * floatsPerElement << "\"> ";
-    PushTag();
-
-    if( pType == FloatType_TexCoord2 )
-    {
-        for( size_t a = 0; a < pElementCount; ++a )
-        {
-            mOutput << pData[a*3+0] << " ";
-            mOutput << pData[a*3+1] << " ";
-        }
-    }
-    else if( pType == FloatType_Color )
-    {
-        for( size_t a = 0; a < pElementCount; ++a )
-        {
-            mOutput << pData[a*4+0] << " ";
-            mOutput << pData[a*4+1] << " ";
-            mOutput << pData[a*4+2] << " ";
-        }
-    }
-    else
-    {
-        for( size_t a = 0; a < pElementCount * floatsPerElement; ++a )
-            mOutput << pData[a] << " ";
-    }
-    mOutput << "</float_array>" << endstr;
-    PopTag();
-
-    // the usual Collada fun. Let's bloat it even more!
-    mOutput << startstr << "<technique_common>" << endstr;
-    PushTag();
-    mOutput << startstr << "<accessor count=\"" << pElementCount << "\" offset=\"0\" source=\"#" << arrayId << "\" stride=\"" << floatsPerElement << "\">" << endstr;
-    PushTag();
-
-    switch( pType )
-    {
-        case FloatType_Vector:
-            mOutput << startstr << "<param name=\"X\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"Y\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"Z\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_TexCoord2:
-            mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_TexCoord3:
-            mOutput << startstr << "<param name=\"S\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"T\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"P\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_Color:
-            mOutput << startstr << "<param name=\"R\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"G\" type=\"float\" />" << endstr;
-            mOutput << startstr << "<param name=\"B\" type=\"float\" />" << endstr;
-            break;
-
-        case FloatType_Mat4x4:
-            mOutput << startstr << "<param name=\"TRANSFORM\" type=\"float4x4\" />" << endstr;
-            break;
-
-        case FloatType_Weight:
-            mOutput << startstr << "<param name=\"WEIGHT\" type=\"float\" />" << endstr;
-            break;
-
-		// customized, add animation related
-		case FloatType_Time:
-			mOutput << startstr << "<param name=\"TIME\" type=\"float\" />" << endstr;
-			break;
-
-	}
-
-    PopTag();
-    mOutput << startstr << "</accessor>" << endstr;
-    PopTag();
-    mOutput << startstr << "</technique_common>" << endstr;
-    PopTag();
-    mOutput << startstr << "</source>" << endstr;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Writes the scene library
-void ColladaExporter::WriteSceneLibrary()
-{
-    const std::string sceneName = XMLEscape(mScene->mRootNode->mName.C_Str());
-    const std::string sceneId = XMLIDEncode(mScene->mRootNode->mName.C_Str());
-
-    mOutput << startstr << "<library_visual_scenes>" << endstr;
-    PushTag();
-    mOutput << startstr << "<visual_scene id=\"" + sceneId + "\" name=\"" + sceneName + "\">" << endstr;
-    PushTag();
-
-    // start recursive write at the root node
-    for( size_t a = 0; a < mScene->mRootNode->mNumChildren; ++a )
-        WriteNode( mScene, mScene->mRootNode->mChildren[a]);
-
-    PopTag();
-    mOutput << startstr << "</visual_scene>" << endstr;
-    PopTag();
-    mOutput << startstr << "</library_visual_scenes>" << endstr;
-}
-// ------------------------------------------------------------------------------------------------
-void ColladaExporter::WriteAnimationLibrary(size_t pIndex)
-{
-	const aiAnimation * anim = mScene->mAnimations[pIndex];
-	
-	if ( anim->mNumChannels == 0 && anim->mNumMeshChannels == 0 && anim->mNumMorphMeshChannels ==0 )
-		return;
-	
-	const std::string animation_name_escaped = XMLEscape( anim->mName.C_Str() );
-	std::string idstr = anim->mName.C_Str();
-	std::string ending = std::string( "AnimId" ) + to_string(pIndex);
-	if (idstr.length() >= ending.length()) {
-		if (0 != idstr.compare (idstr.length() - ending.length(), ending.length(), ending)) {
-			idstr = idstr + ending;
-		}
-	} else {
-		idstr = idstr + ending;
-	}
-
-	const std::string idstrEscaped = XMLIDEncode(idstr);
-	
-	mOutput << startstr << "<animation id=\"" + idstrEscaped + "\" name=\"" + animation_name_escaped + "\">" << endstr;
-	PushTag();
-
-    std::string cur_node_idstr;
-	for (size_t a = 0; a < anim->mNumChannels; ++a) {
-		const aiNodeAnim * nodeAnim = anim->mChannels[a];
-		
-		// sanity check
-        if (nodeAnim->mNumPositionKeys != nodeAnim->mNumScalingKeys || nodeAnim->mNumPositionKeys != nodeAnim->mNumRotationKeys) {
-            continue;
-        }
-		
-		{
-            cur_node_idstr.clear();
-            cur_node_idstr += nodeAnim->mNodeName.data;
-            cur_node_idstr += std::string("_matrix-input");
-
-			std::vector<ai_real> frames;
-			for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
-				frames.push_back(static_cast<ai_real>(nodeAnim->mPositionKeys[i].mTime));
-			}
-			
-			WriteFloatArray(cur_node_idstr, FloatType_Time, (const ai_real *)frames.data(), frames.size());
-			frames.clear();
-		}
-		
-		{
-            cur_node_idstr.clear();
-
-            cur_node_idstr += nodeAnim->mNodeName.data;
-            cur_node_idstr += std::string("_matrix-output");
-			
-			std::vector<ai_real> keyframes;
-			keyframes.reserve(nodeAnim->mNumPositionKeys * 16);
-			for( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
-				aiVector3D Scaling = nodeAnim->mScalingKeys[i].mValue;
-				aiMatrix4x4 ScalingM;  // identity
-				ScalingM[0][0] = Scaling.x; ScalingM[1][1] = Scaling.y; ScalingM[2][2] = Scaling.z;
-				
-				aiQuaternion RotationQ = nodeAnim->mRotationKeys[i].mValue;
-				aiMatrix4x4 s = aiMatrix4x4( RotationQ.GetMatrix() );
-				aiMatrix4x4 RotationM(s.a1, s.a2, s.a3, 0, s.b1, s.b2, s.b3, 0, s.c1, s.c2, s.c3, 0, 0, 0, 0, 1);
-				
-				aiVector3D Translation = nodeAnim->mPositionKeys[i].mValue;
-				aiMatrix4x4 TranslationM;	// identity
-				TranslationM[0][3] = Translation.x; TranslationM[1][3] = Translation.y; TranslationM[2][3] = Translation.z;
-				
-				// Combine the above transformations
-				aiMatrix4x4 mat = TranslationM * RotationM * ScalingM;
-				
-				for( unsigned int j = 0; j < 4; ++j) {
-					keyframes.insert(keyframes.end(), mat[j], mat[j] + 4);
-                }
-			}
-			
-			WriteFloatArray(cur_node_idstr, FloatType_Mat4x4, (const ai_real *)keyframes.data(), keyframes.size() / 16);
-		}
-		
-		{
-			std::vector<std::string> names;
-			for ( size_t i = 0; i < nodeAnim->mNumPositionKeys; ++i) {
-				if ( nodeAnim->mPreState == aiAnimBehaviour_DEFAULT
-					|| nodeAnim->mPreState == aiAnimBehaviour_LINEAR
-					|| nodeAnim->mPreState == aiAnimBehaviour_REPEAT
-					) {
-					names.push_back( "LINEAR" );
-				} else if (nodeAnim->mPostState == aiAnimBehaviour_CONSTANT) {
-					names.push_back( "STEP" );
-				}
-			}
-			
-			const std::string cur_node_idstr2 = nodeAnim->mNodeName.data + std::string("_matrix-interpolation");
-            std::string arrayId = XMLIDEncode(cur_node_idstr2) + "-array";
-			
-			mOutput << startstr << "<source id=\"" << XMLIDEncode(cur_node_idstr2) << "\">" << endstr;
-			PushTag();
-			
-			// source array
-			mOutput << startstr << "<Name_array id=\"" << arrayId << "\" count=\"" << names.size() << "\"> ";
-			for( size_t aa = 0; aa < names.size(); ++aa ) {
-				mOutput << names[aa] << " ";
-            }
-			mOutput << "</Name_array>" << endstr;
-			
-			mOutput << startstr << "<technique_common>" << endstr;
-			PushTag();
-
-			mOutput << startstr << "<accessor source=\"#" << arrayId << "\" count=\"" << names.size() << "\" stride=\"" << 1 << "\">" << endstr;
-			PushTag();
-			
-			mOutput << startstr << "<param name=\"INTERPOLATION\" type=\"name\"></param>" << endstr;
-			
-			PopTag();
-			mOutput << startstr << "</accessor>" << endstr;
-			
-			PopTag();
-			mOutput << startstr << "</technique_common>" << endstr;
-
-			PopTag();
-			mOutput << startstr << "</source>" << endstr;
-		}
-	}
-	
-	for (size_t a = 0; a < anim->mNumChannels; ++a) {
-		const aiNodeAnim * nodeAnim = anim->mChannels[a];
-		
-		{
-		// samplers
-			const std::string node_idstr = nodeAnim->mNodeName.data + std::string("_matrix-sampler");
-			mOutput << startstr << "<sampler id=\"" << XMLIDEncode(node_idstr) << "\">" << endstr;
-			PushTag();
-			
-			mOutput << startstr << "<input semantic=\"INPUT\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-input") ) << "\"/>" << endstr;
-			mOutput << startstr << "<input semantic=\"OUTPUT\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-output") ) << "\"/>" << endstr;
-			mOutput << startstr << "<input semantic=\"INTERPOLATION\" source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-interpolation") ) << "\"/>" << endstr;
-			
-			PopTag();
-			mOutput << startstr << "</sampler>" << endstr;
-		}
-	}
-	
-	for (size_t a = 0; a < anim->mNumChannels; ++a) {
-		const aiNodeAnim * nodeAnim = anim->mChannels[a];
-		
-		{
-		// channels
-			mOutput << startstr << "<channel source=\"#" << XMLIDEncode( nodeAnim->mNodeName.data + std::string("_matrix-sampler") ) << "\" target=\"" << XMLIDEncode(nodeAnim->mNodeName.data) << "/matrix\"/>" << endstr;
-		}
-	}
-	
-	PopTag();
-	mOutput << startstr << "</animation>" << endstr;
-	
-}
-// ------------------------------------------------------------------------------------------------
-void ColladaExporter::WriteAnimationsLibrary()
-{
-	if ( mScene->mNumAnimations > 0 ) {
-		mOutput << startstr << "<library_animations>" << endstr;
-		PushTag();
-		
-		// start recursive write at the root node
-		for( size_t a = 0; a < mScene->mNumAnimations; ++a)
-			WriteAnimationLibrary( a );
-
-		PopTag();
-		mOutput << startstr << "</library_animations>" << endstr;
-	}
-}
-// ------------------------------------------------------------------------------------------------
-// Helper to find a bone by name in the scene
-aiBone* findBone( const aiScene* scene, const char * name) {
-    for (size_t m=0; m<scene->mNumMeshes; m++) {
-        aiMesh * mesh = scene->mMeshes[m];
-        for (size_t b=0; b<mesh->mNumBones; b++) {
-            aiBone * bone = mesh->mBones[b];
-            if (0 == strcmp(name, bone->mName.C_Str())) {
-                return bone;
-            }
-        }
-    }
-    return NULL;
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiNode * findBoneNode( const aiNode* aNode, const aiBone* bone)
-{
-	if ( aNode && bone && aNode->mName == bone->mName ) {
-		return aNode;
-	}
-	
-	if ( aNode && bone ) {
-		for (unsigned int i=0; i < aNode->mNumChildren; ++i) {
-			aiNode * aChild = aNode->mChildren[i];
-			const aiNode * foundFromChild = 0;
-			if ( aChild ) {
-				foundFromChild = findBoneNode( aChild, bone );
-				if ( foundFromChild ) return foundFromChild;
-			}
-		}
-	}
-	
-	return NULL;
-}
-
-const aiNode * findSkeletonRootNode( const aiScene* scene, const aiMesh * mesh)
-{
-	std::set<const aiNode*> topParentBoneNodes;
-	if ( mesh && mesh->mNumBones > 0 ) {
-		for (unsigned int i=0; i < mesh->mNumBones; ++i) {
-			aiBone * bone = mesh->mBones[i];
-
-			const aiNode * node = findBoneNode( scene->mRootNode, bone);
-			if ( node ) {
-				while ( node->mParent && findBone(scene, node->mParent->mName.C_Str() ) != 0 ) {
-					node = node->mParent;
-				}
-				topParentBoneNodes.insert( node );
-			}
-		}
-	}
-	
-	if ( !topParentBoneNodes.empty() ) {
-		const aiNode * parentBoneNode = *topParentBoneNodes.begin();
-		if ( topParentBoneNodes.size() == 1 ) {
-			return parentBoneNode;
-		} else {
-			for (auto it : topParentBoneNodes) {
-				if ( it->mParent ) return it->mParent;
-			}
-			return parentBoneNode;
-		}
-	}
-	
-	return NULL;
-}
-
-// ------------------------------------------------------------------------------------------------
-// Recursively writes the given node
-void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
-{
-    // the node must have a name
-    if (pNode->mName.length == 0)
-    {
-        std::stringstream ss;
-        ss << "Node_" << pNode;
-        pNode->mName.Set(ss.str());
-    }
-
-    // If the node is associated with a bone, it is a joint node (JOINT)
-    // otherwise it is a normal node (NODE)
-    const char * node_type;
-    bool is_joint, is_skeleton_root = false;
-    if (nullptr == findBone(pScene, pNode->mName.C_Str())) {
-        node_type = "NODE";
-        is_joint = false;
-    } else {
-        node_type = "JOINT";
-        is_joint = true;
-        if (!pNode->mParent || nullptr == findBone(pScene, pNode->mParent->mName.C_Str())) {
-            is_skeleton_root = true;
-        }
-    }
-
-    const std::string node_id = XMLIDEncode(pNode->mName.data);
-    const std::string node_name = XMLEscape(pNode->mName.data);
-	mOutput << startstr << "<node ";
-	if(is_skeleton_root) {
-		mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id +"\"" : "") ; // For now, only support one skeleton in a scene.
-		mFoundSkeletonRootNodeID = node_id;
-	} else {
-		mOutput << "id=\"" << node_id << "\" " << (is_joint ? "sid=\"" + node_id +"\"": "") ;
-	}
-	
-    mOutput << " name=\"" << node_name
-            << "\" type=\"" << node_type
-            << "\">" << endstr;
-    PushTag();
-
-    // write transformation - we can directly put the matrix there
-    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
-    aiMatrix4x4 mat = pNode->mTransformation;
-
-    // If this node is a Camera node, the camera coordinate system needs to be multiplied in.
-    // When importing from Collada, the mLookAt is set to 0, 0, -1, and the node transform is unchanged.
-    // When importing from a different format, mLookAt is set to 0, 0, 1. Therefore, the local camera
-    // coordinate system must be changed to matche the Collada specification.
-    for (size_t i = 0; i<mScene->mNumCameras; i++){
-        if (mScene->mCameras[i]->mName == pNode->mName){
-            aiMatrix4x4 sourceView;
-            mScene->mCameras[i]->GetCameraMatrix(sourceView);
-
-            aiMatrix4x4 colladaView;
-            colladaView.a1 = colladaView.c3 = -1; // move into -z space.
-            mat *= (sourceView * colladaView);
-            break;
-        }
-    }
-	
-	// customized, sid should be 'matrix' to match with loader code.
-    //mOutput << startstr << "<matrix sid=\"transform\">";
-	mOutput << startstr << "<matrix sid=\"matrix\">";
-	
-    mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";
-    mOutput << mat.b1 << " " << mat.b2 << " " << mat.b3 << " " << mat.b4 << " ";
-    mOutput << mat.c1 << " " << mat.c2 << " " << mat.c3 << " " << mat.c4 << " ";
-    mOutput << mat.d1 << " " << mat.d2 << " " << mat.d3 << " " << mat.d4;
-    mOutput << "</matrix>" << endstr;
-
-    if(pNode->mNumMeshes==0){
-        //check if it is a camera node
-        for(size_t i=0; i<mScene->mNumCameras; i++){
-            if(mScene->mCameras[i]->mName == pNode->mName){
-                mOutput << startstr <<"<instance_camera url=\"#" << node_id << "-camera\"/>" << endstr;
-                break;
-            }
-        }
-        //check if it is a light node
-        for(size_t i=0; i<mScene->mNumLights; i++){
-            if(mScene->mLights[i]->mName == pNode->mName){
-                mOutput << startstr <<"<instance_light url=\"#" << node_id << "-light\"/>" << endstr;
-                break;
-            }
-        }
-
-    }else
-    // instance every geometry
-    for( size_t a = 0; a < pNode->mNumMeshes; ++a )
-    {
-        const aiMesh* mesh = mScene->mMeshes[pNode->mMeshes[a]];
-        // do not instantiate mesh if empty. I wonder how this could happen
-        if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-            continue;
-
-        const std::string meshName = mesh->mName.length == 0 ? GetMeshId(pNode->mMeshes[a]) : mesh->mName.C_Str();
-
-        if( mesh->mNumBones == 0 )
-        {
-            mOutput << startstr << "<instance_geometry url=\"#" << XMLIDEncode(meshName) << "\">" << endstr;
-            PushTag();
-        }
-        else
-        {
-            mOutput << startstr
-                    << "<instance_controller url=\"#" << XMLIDEncode(meshName) << "-skin\">"
-                    << endstr;
-            PushTag();
-
-			// note! this mFoundSkeletonRootNodeID some how affects animation, it makes the mesh attaches to armature skeleton root node.
-			// use the first bone to find skeleton root
-			const aiNode * skeletonRootBoneNode = findSkeletonRootNode( pScene, mesh );
-			if ( skeletonRootBoneNode ) {
-				mFoundSkeletonRootNodeID = XMLIDEncode( skeletonRootBoneNode->mName.C_Str() );
-			}
-            mOutput << startstr << "<skeleton>#" << mFoundSkeletonRootNodeID << "</skeleton>" << endstr;
-        }
-        mOutput << startstr << "<bind_material>" << endstr;
-        PushTag();
-        mOutput << startstr << "<technique_common>" << endstr;
-        PushTag();
-        mOutput << startstr << "<instance_material symbol=\"defaultMaterial\" target=\"#" << XMLIDEncode(materials[mesh->mMaterialIndex].name) << "\">" << endstr;
-        PushTag();
-        for( size_t aa = 0; aa < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++aa )
-        {
-            if( mesh->HasTextureCoords( static_cast<unsigned int>(aa) ) )
-                // semantic       as in <texture texcoord=...>
-                // input_semantic as in <input semantic=...>
-                // input_set      as in <input set=...>
-                mOutput << startstr << "<bind_vertex_input semantic=\"CHANNEL" << aa << "\" input_semantic=\"TEXCOORD\" input_set=\"" << aa << "\"/>" << endstr;
-        }
-        PopTag();
-        mOutput << startstr << "</instance_material>" << endstr;
-        PopTag();
-        mOutput << startstr << "</technique_common>" << endstr;
-        PopTag();
-        mOutput << startstr << "</bind_material>" << endstr;
-        
-        PopTag();
-        if( mesh->mNumBones == 0)
-            mOutput << startstr << "</instance_geometry>" << endstr;
-        else
-            mOutput << startstr << "</instance_controller>" << endstr;
-    }
-
-    // recurse into subnodes
-    for( size_t a = 0; a < pNode->mNumChildren; ++a )
-        WriteNode( pScene, pNode->mChildren[a]);
-
-    PopTag();
-    mOutput << startstr << "</node>" << endstr;
-}
-
-#endif
-#endif
diff --git a/code/Common/ImporterRegistry.cpp b/code/Common/ImporterRegistry.cpp
index ff0e3ae76..d66d7de8d 100644
--- a/code/Common/ImporterRegistry.cpp
+++ b/code/Common/ImporterRegistry.cpp
@@ -46,330 +46,326 @@ directly (unless you are adding new loaders), instead use the
 corresponding preprocessor flag to selectively disable formats.
 */
 
-#include <vector>
 #include <assimp/BaseImporter.h>
+#include <vector>
 
 // ------------------------------------------------------------------------------------------------
 // Importers
 // (include_new_importers_here)
 // ------------------------------------------------------------------------------------------------
 #ifndef ASSIMP_BUILD_NO_X_IMPORTER
-#   include "X/XFileImporter.h"
+#include "AssetLib/X/XFileImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-#   include "AMF/AMFImporter.hpp"
+#include "AssetLib/AMF/AMFImporter.hpp"
 #endif
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
-#   include "3DS/3DSLoader.h"
+#include "AssetLib/3DS/3DSLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MD3_IMPORTER
-#   include "MD3/MD3Loader.h"
+#include "AssetLib/MD3/MD3Loader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MDL_IMPORTER
-#   include "MDL/MDLLoader.h"
+#include "AssetLib/MDL/MDLLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MD2_IMPORTER
-#   include "MD2/MD2Loader.h"
+#include "AssetLib/MD2/MD2Loader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_PLY_IMPORTER
-#   include "Ply/PlyLoader.h"
+#include "AssetLib/Ply/PlyLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_ASE_IMPORTER
-#   include "ASE/ASELoader.h"
+#include "AssetLib/ASE/ASELoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OBJ_IMPORTER
-#   include "Obj/ObjFileImporter.h"
+#include "AssetLib/Obj/ObjFileImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_HMP_IMPORTER
-#   include "HMP/HMPLoader.h"
+#include "AssetLib/HMP/HMPLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SMD_IMPORTER
-#   include "SMD/SMDLoader.h"
+#include "AssetLib/SMD/SMDLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MDC_IMPORTER
-#   include "MDC/MDCLoader.h"
+#include "AssetLib/MDC/MDCLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MD5_IMPORTER
-#   include "MD5/MD5Loader.h"
+#include "AssetLib/MD5/MD5Loader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_STL_IMPORTER
-#   include "STL/STLLoader.h"
+#include "AssetLib/STL/STLLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_LWO_IMPORTER
-#   include "LWO/LWOLoader.h"
+#include "AssetLib/LWO/LWOLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_DXF_IMPORTER
-#   include "DXF/DXFLoader.h"
+#include "AssetLib/DXF/DXFLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_NFF_IMPORTER
-#   include "NFF/NFFLoader.h"
+#include "AssetLib/NFF/NFFLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
-#   include "Raw/RawLoader.h"
+#include "AssetLib/Raw/RawLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SIB_IMPORTER
-#   include "SIB/SIBImporter.h"
+#include "AssetLib/SIB/SIBImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OFF_IMPORTER
-#   include "OFF/OFFLoader.h"
+#include "AssetLib/OFF/OFFLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_AC_IMPORTER
-#   include "AC/ACLoader.h"
+#include "AssetLib/AC/ACLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_BVH_IMPORTER
-#   include "BVH/BVHLoader.h"
+#include "AssetLib/BVH/BVHLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IRRMESH_IMPORTER
-#   include "Irr/IRRMeshLoader.h"
+#include "AssetLib/Irr/IRRMeshLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IRR_IMPORTER
-#   include "Irr/IRRLoader.h"
+#include "AssetLib/Irr/IRRLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_Q3D_IMPORTER
-#   include "Q3D/Q3DLoader.h"
+#include "AssetLib/Q3D/Q3DLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_B3D_IMPORTER
-#   include "B3D/B3DImporter.h"
+#include "AssetLib/B3D/B3DImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_COLLADA_IMPORTER
-#   include "Collada/ColladaLoader.h"
+#include "AssetLib/Collada/ColladaLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
-#   include "Terragen/TerragenLoader.h"
+#include "AssetLib/Terragen/TerragenLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_CSM_IMPORTER
-#   include "CSM/CSMLoader.h"
+#include "AssetLib/CSM/CSMLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
-#   include "Unreal/UnrealLoader.h"
+#include "AssetLib/Unreal/UnrealLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_LWS_IMPORTER
-#   include "LWS/LWSLoader.h"
+#include "AssetLib/LWS/LWSLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OGRE_IMPORTER
-#   include "Ogre/OgreImporter.h"
+#include "AssetLib/Ogre/OgreImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_OPENGEX_IMPORTER
-#   include "OpenGEX/OpenGEXImporter.h"
+#include "AssetLib/OpenGEX/OpenGEXImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_MS3D_IMPORTER
-#   include "MS3D/MS3DLoader.h"
+#include "AssetLib/MS3D/MS3DLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_COB_IMPORTER
-#   include "COB/COBLoader.h"
+#include "AssetLib/COB/COBLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
-#   include "Blender/BlenderLoader.h"
+#include "AssetLib/Blender/BlenderLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_Q3BSP_IMPORTER
-#   include "Q3BSP/Q3BSPFileImporter.h"
+#include "AssetLib/Q3BSP/Q3BSPFileImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_NDO_IMPORTER
-#   include "NDO/NDOLoader.h"
+#include "AssetLib/NDO/NDOLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_IFC_IMPORTER
-#   include "Importer/IFC/IFCLoader.h"
+#include "AssetLib/IFC/IFCLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_XGL_IMPORTER
-#   include "XGL/XGLLoader.h"
+#include "AssetLib/XGL/XGLLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
-#   include "FBX/FBXImporter.h"
+#include "AssetLib/FBX/FBXImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_ASSBIN_IMPORTER
-#   include "Assbin/AssbinLoader.h"
+#include "AssetLib/Assbin/AssbinLoader.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_GLTF_IMPORTER
-#   include "glTF/glTFImporter.h"
-#   include "glTF2/glTF2Importer.h"
+#include "AssetLib/glTF/glTFImporter.h"
+#include "AssetLib/glTF2/glTF2Importer.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_C4D_IMPORTER
-#   include "C4D/C4DImporter.h"
+#include "AssetLib/C4D/C4DImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
-#   include "3MF/D3MFImporter.h"
+#include "AssetLib/3MF/D3MFImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-#   include "X3D/X3DImporter.hpp"
+#include "AssetLib/X3D/X3DImporter.hpp"
 #endif
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-#   include "MMD/MMDImporter.h"
+#include "AssetLib/MMD/MMDImporter.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
-#   include "M3D/M3DImporter.h"
+#include "AssetLib/M3D/M3DImporter.h"
 #endif
-//#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-//#   include "Importer/StepFile/StepFileImporter.h"
-//#endif
 
 namespace Assimp {
 
 // ------------------------------------------------------------------------------------------------
-void GetImporterInstanceList(std::vector< BaseImporter* >& out)
-{
+void GetImporterInstanceList(std::vector<BaseImporter *> &out) {
     // ----------------------------------------------------------------------------
     // Add an instance of each worker class here
     // (register_new_importers_here)
     // ----------------------------------------------------------------------------
     out.reserve(64);
 #if (!defined ASSIMP_BUILD_NO_X_IMPORTER)
-    out.push_back( new XFileImporter());
+    out.push_back(new XFileImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_OBJ_IMPORTER)
-    out.push_back( new ObjFileImporter());
+    out.push_back(new ObjFileImporter());
 #endif
 #ifndef ASSIMP_BUILD_NO_AMF_IMPORTER
-	out.push_back( new AMFImporter() );
+    out.push_back(new AMFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
-    out.push_back( new Discreet3DSImporter());
+    out.push_back(new Discreet3DSImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_M3D_IMPORTER)
-    out.push_back( new M3DImporter());
+    out.push_back(new M3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MD3_IMPORTER)
-    out.push_back( new MD3Importer());
+    out.push_back(new MD3Importer());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MD2_IMPORTER)
-    out.push_back( new MD2Importer());
+    out.push_back(new MD2Importer());
 #endif
 #if (!defined ASSIMP_BUILD_NO_PLY_IMPORTER)
-    out.push_back( new PLYImporter());
+    out.push_back(new PLYImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MDL_IMPORTER)
-    out.push_back( new MDLImporter());
+    out.push_back(new MDLImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_ASE_IMPORTER)
-  #if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
-    out.push_back( new ASEImporter());
-#  endif
+#if (!defined ASSIMP_BUILD_NO_3DS_IMPORTER)
+    out.push_back(new ASEImporter());
+#endif
 #endif
 #if (!defined ASSIMP_BUILD_NO_HMP_IMPORTER)
-    out.push_back( new HMPImporter());
+    out.push_back(new HMPImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_SMD_IMPORTER)
-    out.push_back( new SMDImporter());
+    out.push_back(new SMDImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MDC_IMPORTER)
-    out.push_back( new MDCImporter());
+    out.push_back(new MDCImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MD5_IMPORTER)
-    out.push_back( new MD5Importer());
+    out.push_back(new MD5Importer());
 #endif
 #if (!defined ASSIMP_BUILD_NO_STL_IMPORTER)
-    out.push_back( new STLImporter());
+    out.push_back(new STLImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_LWO_IMPORTER)
-    out.push_back( new LWOImporter());
+    out.push_back(new LWOImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_DXF_IMPORTER)
-    out.push_back( new DXFImporter());
+    out.push_back(new DXFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_NFF_IMPORTER)
-    out.push_back( new NFFImporter());
+    out.push_back(new NFFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_RAW_IMPORTER)
-    out.push_back( new RAWImporter());
+    out.push_back(new RAWImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_SIB_IMPORTER)
-    out.push_back( new SIBImporter());
+    out.push_back(new SIBImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_OFF_IMPORTER)
-    out.push_back( new OFFImporter());
+    out.push_back(new OFFImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_AC_IMPORTER)
-    out.push_back( new AC3DImporter());
+    out.push_back(new AC3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_BVH_IMPORTER)
-    out.push_back( new BVHLoader());
+    out.push_back(new BVHLoader());
 #endif
 #if (!defined ASSIMP_BUILD_NO_IRRMESH_IMPORTER)
-    out.push_back( new IRRMeshImporter());
+    out.push_back(new IRRMeshImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_IRR_IMPORTER)
-    out.push_back( new IRRImporter());
+    out.push_back(new IRRImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_Q3D_IMPORTER)
-    out.push_back( new Q3DImporter());
+    out.push_back(new Q3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_B3D_IMPORTER)
-    out.push_back( new B3DImporter());
+    out.push_back(new B3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_COLLADA_IMPORTER)
-    out.push_back( new ColladaLoader());
+    out.push_back(new ColladaLoader());
 #endif
 #if (!defined ASSIMP_BUILD_NO_TERRAGEN_IMPORTER)
-    out.push_back( new TerragenImporter());
+    out.push_back(new TerragenImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_CSM_IMPORTER)
-    out.push_back( new CSMImporter());
+    out.push_back(new CSMImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_3D_IMPORTER)
-    out.push_back( new UnrealImporter());
+    out.push_back(new UnrealImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_LWS_IMPORTER)
-    out.push_back( new LWSImporter());
+    out.push_back(new LWSImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_OGRE_IMPORTER)
-    out.push_back( new Ogre::OgreImporter());
+    out.push_back(new Ogre::OgreImporter());
 #endif
-#if (!defined ASSIMP_BUILD_NO_OPENGEX_IMPORTER )
-    out.push_back( new OpenGEX::OpenGEXImporter() );
+#if (!defined ASSIMP_BUILD_NO_OPENGEX_IMPORTER)
+    out.push_back(new OpenGEX::OpenGEXImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_MS3D_IMPORTER)
-    out.push_back( new MS3DImporter());
+    out.push_back(new MS3DImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_COB_IMPORTER)
-    out.push_back( new COBImporter());
+    out.push_back(new COBImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_BLEND_IMPORTER)
-    out.push_back( new BlenderImporter());
+    out.push_back(new BlenderImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_Q3BSP_IMPORTER)
-    out.push_back( new Q3BSPFileImporter() );
+    out.push_back(new Q3BSPFileImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_NDO_IMPORTER)
-    out.push_back( new NDOImporter() );
+    out.push_back(new NDOImporter());
 #endif
 #if (!defined ASSIMP_BUILD_NO_IFC_IMPORTER)
-    out.push_back( new IFCImporter() );
+    out.push_back(new IFCImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_XGL_IMPORTER )
-    out.push_back( new XGLImporter() );
+#if (!defined ASSIMP_BUILD_NO_XGL_IMPORTER)
+    out.push_back(new XGLImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_FBX_IMPORTER )
-    out.push_back( new FBXImporter() );
+#if (!defined ASSIMP_BUILD_NO_FBX_IMPORTER)
+    out.push_back(new FBXImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_ASSBIN_IMPORTER )
-    out.push_back( new AssbinImporter() );
+#if (!defined ASSIMP_BUILD_NO_ASSBIN_IMPORTER)
+    out.push_back(new AssbinImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_GLTF_IMPORTER )
-    out.push_back( new glTFImporter() );
-    out.push_back( new glTF2Importer() );
+#if (!defined ASSIMP_BUILD_NO_GLTF_IMPORTER)
+    out.push_back(new glTFImporter());
+    out.push_back(new glTF2Importer());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_C4D_IMPORTER )
-    out.push_back( new C4DImporter() );
+#if (!defined ASSIMP_BUILD_NO_C4D_IMPORTER)
+    out.push_back(new C4DImporter());
 #endif
-#if ( !defined ASSIMP_BUILD_NO_3MF_IMPORTER )
-    out.push_back( new D3MFImporter() );
+#if (!defined ASSIMP_BUILD_NO_3MF_IMPORTER)
+    out.push_back(new D3MFImporter());
 #endif
 #ifndef ASSIMP_BUILD_NO_X3D_IMPORTER
-    out.push_back( new X3DImporter() );
+    out.push_back(new X3DImporter());
 #endif
 #ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-    out.push_back( new MMDImporter() );
+    out.push_back(new MMDImporter());
 #endif
-//#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
-//    out.push_back(new StepFile::StepFileImporter());
-//#endif
+    //#ifndef ASSIMP_BUILD_NO_STEP_IMPORTER
+    //    out.push_back(new StepFile::StepFileImporter());
+    //#endif
 }
 
 /** will delete all registered importers. */
-void DeleteImporterInstanceList(std::vector< BaseImporter* >& deleteList){
-	for(size_t i= 0; i<deleteList.size();++i){
-		delete deleteList[i];
-		deleteList[i]=nullptr;
-	}//for
+void DeleteImporterInstanceList(std::vector<BaseImporter *> &deleteList) {
+    for (size_t i = 0; i < deleteList.size(); ++i) {
+        delete deleteList[i];
+        deleteList[i] = nullptr;
+    } //for
 }
 
 } // namespace Assimp
diff --git a/code/LWO/LWOFileData.h b/code/LWO/LWOFileData.h
deleted file mode 100644
index 33fac8c39..000000000
--- a/code/LWO/LWOFileData.h
+++ /dev/null
@@ -1,703 +0,0 @@
-/*
-Open Asset Import Library (assimp)
-----------------------------------------------------------------------
-
-Copyright (c) 2006-2020, 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 LWOFileData.h
- *  @brief Defines chunk constants used by the LWO file format
-
-The chunks are taken from the official LightWave SDK headers.
-
-*/
-#ifndef AI_LWO_FILEDATA_INCLUDED
-#define AI_LWO_FILEDATA_INCLUDED
-
-// STL headers
-#include <vector>
-#include <list>
-
-// public ASSIMP headers
-#include <assimp/mesh.h>
-
-// internal headers
-#include "Common/IFF.h"
-#include "LWO/LWOAnimation.h"
-
-namespace Assimp {
-namespace LWO {
-
-#define AI_LWO_FOURCC_LWOB AI_IFF_FOURCC('L','W','O','B')
-#define AI_LWO_FOURCC_LWO2 AI_IFF_FOURCC('L','W','O','2')
-#define AI_LWO_FOURCC_LXOB AI_IFF_FOURCC('L','X','O','B')
-
-// chunks specific to the LWOB format
-#define AI_LWO_SRFS  AI_IFF_FOURCC('S','R','F','S')
-#define AI_LWO_FLAG  AI_IFF_FOURCC('F','L','A','G')
-#define AI_LWO_VLUM  AI_IFF_FOURCC('V','L','U','M')
-#define AI_LWO_VDIF  AI_IFF_FOURCC('V','D','I','F')
-#define AI_LWO_VSPC  AI_IFF_FOURCC('V','S','P','C')
-#define AI_LWO_RFLT  AI_IFF_FOURCC('R','F','L','T')
-#define AI_LWO_BTEX  AI_IFF_FOURCC('B','T','E','X')
-#define AI_LWO_CTEX  AI_IFF_FOURCC('C','T','E','X')
-#define AI_LWO_DTEX  AI_IFF_FOURCC('D','T','E','X')
-#define AI_LWO_LTEX  AI_IFF_FOURCC('L','T','E','X')
-#define AI_LWO_RTEX  AI_IFF_FOURCC('R','T','E','X')
-#define AI_LWO_STEX  AI_IFF_FOURCC('S','T','E','X')
-#define AI_LWO_TTEX  AI_IFF_FOURCC('T','T','E','X')
-#define AI_LWO_TFLG  AI_IFF_FOURCC('T','F','L','G')
-#define AI_LWO_TSIZ  AI_IFF_FOURCC('T','S','I','Z')
-#define AI_LWO_TCTR  AI_IFF_FOURCC('T','C','T','R')
-#define AI_LWO_TFAL  AI_IFF_FOURCC('T','F','A','L')
-#define AI_LWO_TVEL  AI_IFF_FOURCC('T','V','E','L')
-#define AI_LWO_TCLR  AI_IFF_FOURCC('T','C','L','R')
-#define AI_LWO_TVAL  AI_IFF_FOURCC('T','V','A','L')
-#define AI_LWO_TAMP  AI_IFF_FOURCC('T','A','M','P')
-#define AI_LWO_TIMG  AI_IFF_FOURCC('T','I','M','G')
-#define AI_LWO_TAAS  AI_IFF_FOURCC('T','A','A','S')
-#define AI_LWO_TREF  AI_IFF_FOURCC('T','R','E','F')
-#define AI_LWO_TOPC  AI_IFF_FOURCC('T','O','P','C')
-#define AI_LWO_SDAT  AI_IFF_FOURCC('S','D','A','T')
-#define AI_LWO_TFP0  AI_IFF_FOURCC('T','F','P','0')
-#define AI_LWO_TFP1  AI_IFF_FOURCC('T','F','P','1')
-
-
-/* top-level chunks */
-#define AI_LWO_LAYR  AI_IFF_FOURCC('L','A','Y','R')
-#define AI_LWO_TAGS  AI_IFF_FOURCC('T','A','G','S')
-#define AI_LWO_PNTS  AI_IFF_FOURCC('P','N','T','S')
-#define AI_LWO_BBOX  AI_IFF_FOURCC('B','B','O','X')
-#define AI_LWO_VMAP  AI_IFF_FOURCC('V','M','A','P')
-#define AI_LWO_VMAD  AI_IFF_FOURCC('V','M','A','D')
-#define AI_LWO_POLS  AI_IFF_FOURCC('P','O','L','S')
-#define AI_LWO_PTAG  AI_IFF_FOURCC('P','T','A','G')
-#define AI_LWO_ENVL  AI_IFF_FOURCC('E','N','V','L')
-#define AI_LWO_CLIP  AI_IFF_FOURCC('C','L','I','P')
-#define AI_LWO_SURF  AI_IFF_FOURCC('S','U','R','F')
-#define AI_LWO_DESC  AI_IFF_FOURCC('D','E','S','C')
-#define AI_LWO_TEXT  AI_IFF_FOURCC('T','E','X','T')
-#define AI_LWO_ICON  AI_IFF_FOURCC('I','C','O','N')
-
-/* polygon types */
-#define AI_LWO_FACE  AI_IFF_FOURCC('F','A','C','E')
-#define AI_LWO_CURV  AI_IFF_FOURCC('C','U','R','V')
-#define AI_LWO_PTCH  AI_IFF_FOURCC('P','T','C','H')
-#define AI_LWO_MBAL  AI_IFF_FOURCC('M','B','A','L')
-#define AI_LWO_BONE  AI_IFF_FOURCC('B','O','N','E')
-#define AI_LWO_SUBD  AI_IFF_FOURCC('S','U','B','D')
-
-/* polygon tags */
-#define AI_LWO_SURF  AI_IFF_FOURCC('S','U','R','F')
-#define AI_LWO_PART  AI_IFF_FOURCC('P','A','R','T')
-#define AI_LWO_SMGP  AI_IFF_FOURCC('S','M','G','P')
-
-/* envelopes */
-#define AI_LWO_PRE   AI_IFF_FOURCC('P','R','E',' ')
-#define AI_LWO_POST  AI_IFF_FOURCC('P','O','S','T')
-#define AI_LWO_KEY   AI_IFF_FOURCC('K','E','Y',' ')
-#define AI_LWO_SPAN  AI_IFF_FOURCC('S','P','A','N')
-#define AI_LWO_TCB   AI_IFF_FOURCC('T','C','B',' ')
-#define AI_LWO_HERM  AI_IFF_FOURCC('H','E','R','M')
-#define AI_LWO_BEZI  AI_IFF_FOURCC('B','E','Z','I')
-#define AI_LWO_BEZ2  AI_IFF_FOURCC('B','E','Z','2')
-#define AI_LWO_LINE  AI_IFF_FOURCC('L','I','N','E')
-#define AI_LWO_STEP  AI_IFF_FOURCC('S','T','E','P')
-
-/* clips */
-#define AI_LWO_STIL  AI_IFF_FOURCC('S','T','I','L')
-#define AI_LWO_ISEQ  AI_IFF_FOURCC('I','S','E','Q')
-#define AI_LWO_ANIM  AI_IFF_FOURCC('A','N','I','M')
-#define AI_LWO_XREF  AI_IFF_FOURCC('X','R','E','F')
-#define AI_LWO_STCC  AI_IFF_FOURCC('S','T','C','C')
-#define AI_LWO_TIME  AI_IFF_FOURCC('T','I','M','E')
-#define AI_LWO_CONT  AI_IFF_FOURCC('C','O','N','T')
-#define AI_LWO_BRIT  AI_IFF_FOURCC('B','R','I','T')
-#define AI_LWO_SATR  AI_IFF_FOURCC('S','A','T','R')
-#define AI_LWO_HUE   AI_IFF_FOURCC('H','U','E',' ')
-#define AI_LWO_GAMM  AI_IFF_FOURCC('G','A','M','M')
-#define AI_LWO_NEGA  AI_IFF_FOURCC('N','E','G','A')
-#define AI_LWO_IFLT  AI_IFF_FOURCC('I','F','L','T')
-#define AI_LWO_PFLT  AI_IFF_FOURCC('P','F','L','T')
-
-/* surfaces */
-#define AI_LWO_COLR  AI_IFF_FOURCC('C','O','L','R')
-#define AI_LWO_LUMI  AI_IFF_FOURCC('L','U','M','I')
-#define AI_LWO_DIFF  AI_IFF_FOURCC('D','I','F','F')
-#define AI_LWO_SPEC  AI_IFF_FOURCC('S','P','E','C')
-#define AI_LWO_GLOS  AI_IFF_FOURCC('G','L','O','S')
-#define AI_LWO_REFL  AI_IFF_FOURCC('R','E','F','L')
-#define AI_LWO_RFOP  AI_IFF_FOURCC('R','F','O','P')
-#define AI_LWO_RIMG  AI_IFF_FOURCC('R','I','M','G')
-#define AI_LWO_RSAN  AI_IFF_FOURCC('R','S','A','N')
-#define AI_LWO_TRAN  AI_IFF_FOURCC('T','R','A','N')
-#define AI_LWO_TROP  AI_IFF_FOURCC('T','R','O','P')
-#define AI_LWO_TIMG  AI_IFF_FOURCC('T','I','M','G')
-#define AI_LWO_RIND  AI_IFF_FOURCC('R','I','N','D')
-#define AI_LWO_TRNL  AI_IFF_FOURCC('T','R','N','L')
-#define AI_LWO_BUMP  AI_IFF_FOURCC('B','U','M','P')
-#define AI_LWO_SMAN  AI_IFF_FOURCC('S','M','A','N')
-#define AI_LWO_SIDE  AI_IFF_FOURCC('S','I','D','E')
-#define AI_LWO_CLRH  AI_IFF_FOURCC('C','L','R','H')
-#define AI_LWO_CLRF  AI_IFF_FOURCC('C','L','R','F')
-#define AI_LWO_ADTR  AI_IFF_FOURCC('A','D','T','R')
-#define AI_LWO_SHRP  AI_IFF_FOURCC('S','H','R','P')
-#define AI_LWO_LINE  AI_IFF_FOURCC('L','I','N','E')
-#define AI_LWO_LSIZ  AI_IFF_FOURCC('L','S','I','Z')
-#define AI_LWO_ALPH  AI_IFF_FOURCC('A','L','P','H')
-#define AI_LWO_AVAL  AI_IFF_FOURCC('A','V','A','L')
-#define AI_LWO_GVAL  AI_IFF_FOURCC('G','V','A','L')
-#define AI_LWO_BLOK  AI_IFF_FOURCC('B','L','O','K')
-#define AI_LWO_VCOL  AI_IFF_FOURCC('V','C','O','L')
-
-/* texture layer */
-#define AI_LWO_TYPE  AI_IFF_FOURCC('T','Y','P','E')
-#define AI_LWO_CHAN  AI_IFF_FOURCC('C','H','A','N')
-#define AI_LWO_NAME  AI_IFF_FOURCC('N','A','M','E')
-#define AI_LWO_ENAB  AI_IFF_FOURCC('E','N','A','B')
-#define AI_LWO_OPAC  AI_IFF_FOURCC('O','P','A','C')
-#define AI_LWO_FLAG  AI_IFF_FOURCC('F','L','A','G')
-#define AI_LWO_PROJ  AI_IFF_FOURCC('P','R','O','J')
-#define AI_LWO_STCK  AI_IFF_FOURCC('S','T','C','K')
-#define AI_LWO_TAMP  AI_IFF_FOURCC('T','A','M','P')
-
-/* texture coordinates */
-#define AI_LWO_TMAP  AI_IFF_FOURCC('T','M','A','P')
-#define AI_LWO_AXIS  AI_IFF_FOURCC('A','X','I','S')
-#define AI_LWO_CNTR  AI_IFF_FOURCC('C','N','T','R')
-#define AI_LWO_SIZE  AI_IFF_FOURCC('S','I','Z','E')
-#define AI_LWO_ROTA  AI_IFF_FOURCC('R','O','T','A')
-#define AI_LWO_OREF  AI_IFF_FOURCC('O','R','E','F')
-#define AI_LWO_FALL  AI_IFF_FOURCC('F','A','L','L')
-#define AI_LWO_CSYS  AI_IFF_FOURCC('C','S','Y','S')
-
-/* image map */
-#define AI_LWO_IMAP  AI_IFF_FOURCC('I','M','A','P')
-#define AI_LWO_IMAG  AI_IFF_FOURCC('I','M','A','G')
-#define AI_LWO_WRAP  AI_IFF_FOURCC('W','R','A','P')
-#define AI_LWO_WRPW  AI_IFF_FOURCC('W','R','P','W')
-#define AI_LWO_WRPH  AI_IFF_FOURCC('W','R','P','H')
-#define AI_LWO_VMAP  AI_IFF_FOURCC('V','M','A','P')
-#define AI_LWO_AAST  AI_IFF_FOURCC('A','A','S','T')
-#define AI_LWO_PIXB  AI_IFF_FOURCC('P','I','X','B')
-
-/* procedural */
-#define AI_LWO_PROC  AI_IFF_FOURCC('P','R','O','C')
-#define AI_LWO_COLR  AI_IFF_FOURCC('C','O','L','R')
-#define AI_LWO_VALU  AI_IFF_FOURCC('V','A','L','U')
-#define AI_LWO_FUNC  AI_IFF_FOURCC('F','U','N','C')
-#define AI_LWO_FTPS  AI_IFF_FOURCC('F','T','P','S')
-#define AI_LWO_ITPS  AI_IFF_FOURCC('I','T','P','S')
-#define AI_LWO_ETPS  AI_IFF_FOURCC('E','T','P','S')
-
-/* gradient */
-#define AI_LWO_GRAD  AI_IFF_FOURCC('G','R','A','D')
-#define AI_LWO_GRST  AI_IFF_FOURCC('G','R','S','T')
-#define AI_LWO_GREN  AI_IFF_FOURCC('G','R','E','N')
-#define AI_LWO_PNAM  AI_IFF_FOURCC('P','N','A','M')
-#define AI_LWO_INAM  AI_IFF_FOURCC('I','N','A','M')
-#define AI_LWO_GRPT  AI_IFF_FOURCC('G','R','P','T')
-#define AI_LWO_FKEY  AI_IFF_FOURCC('F','K','E','Y')
-#define AI_LWO_IKEY  AI_IFF_FOURCC('I','K','E','Y')
-
-/* shader */
-#define AI_LWO_SHDR  AI_IFF_FOURCC('S','H','D','R')
-#define AI_LWO_DATA  AI_IFF_FOURCC('D','A','T','A')
-
-
-/* VMAP types */
-#define AI_LWO_TXUV  AI_IFF_FOURCC('T','X','U','V')
-#define AI_LWO_RGB   AI_IFF_FOURCC('R','G','B',' ')
-#define AI_LWO_RGBA  AI_IFF_FOURCC('R','G','B','A')
-#define AI_LWO_WGHT  AI_IFF_FOURCC('W','G','H','T')
-
-#define AI_LWO_MNVW  AI_IFF_FOURCC('M','N','V','W')
-#define AI_LWO_MORF  AI_IFF_FOURCC('M','O','R','F')
-#define AI_LWO_SPOT  AI_IFF_FOURCC('S','P','O','T')
-#define AI_LWO_PICK  AI_IFF_FOURCC('P','I','C','K')
-
-// MODO extension - per-vertex normal vectors
-#define AI_LWO_MODO_NORM AI_IFF_FOURCC('N', 'O', 'R', 'M')
-
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a face in a LWO file
- *
- * \note We can't use the code in SmoothingGroups.inl here - the mesh
- *   structures of 3DS/ASE and LWO are too different.
- */
-struct Face : public aiFace {
-    //! Default construction
-    Face() AI_NO_EXCEPT
-    : surfaceIndex( 0 )
-    , smoothGroup( 0 )
-    , type( AI_LWO_FACE ) {
-        // empty
-    }
-
-    //! Construction from given type
-    explicit Face(uint32_t _type)
-        : surfaceIndex  (0)
-        , smoothGroup   (0)
-        , type          (_type)
-    {}
-
-    //! Copy construction
-    Face(const Face& f) : aiFace() {
-        *this = f;
-    }
-
-    //! Zero-based index into tags chunk
-    unsigned int surfaceIndex;
-
-    //! Smooth group this face is assigned to
-    unsigned int smoothGroup;
-
-    //! Type of face
-    uint32_t type;
-
-
-    //! Assignment operator
-    Face& operator=(const LWO::Face& f) {
-        aiFace::operator =(f);
-        surfaceIndex    = f.surfaceIndex;
-        smoothGroup     = f.smoothGroup;
-        type            = f.type;
-        return *this;
-    }
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Base structure for all vertex map representations
- */
-struct VMapEntry
-{
-    explicit VMapEntry(unsigned int _dims)
-        :  dims(_dims)
-    {}
-
-    virtual ~VMapEntry() {}
-
-    //! allocates memory for the vertex map
-    virtual void Allocate(unsigned int num)
-    {
-        if (!rawData.empty())
-            return; // return if already allocated
-
-        const unsigned int m = num*dims;
-        rawData.reserve(m + (m>>2u)); // 25% as  extra storage for VMADs
-        rawData.resize(m,0.f);
-        abAssigned.resize(num,false);
-    }
-
-    std::string name;
-    unsigned int dims;
-
-    std::vector<float> rawData;
-    std::vector<bool> abAssigned;
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents an extra vertex color channel
- */
-struct VColorChannel : public VMapEntry
-{
-    VColorChannel()
-        : VMapEntry(4)
-    {}
-
-    //! need to overwrite this function - the alpha channel must
-    //! be initialized to 1.0 by default
-    virtual void Allocate(unsigned int num)
-    {
-        if (!rawData.empty())
-            return; // return if already allocated
-
-        unsigned int m = num*dims;
-        rawData.reserve(m + (m>>2u)); // 25% as  extra storage for VMADs
-        rawData.resize(m);
-
-        for (aiColor4D* p = (aiColor4D*)&rawData[0]; p < (aiColor4D*)&rawData[m-1]; ++p)
-            p->a = 1.f;
-
-        abAssigned.resize(num,false);
-    }
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents an extra vertex UV channel
- */
-struct UVChannel : public VMapEntry
-{
-    UVChannel()
-        : VMapEntry(2)
-    {}
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents a weight map
- */
-struct WeightChannel : public VMapEntry
-{
-    WeightChannel()
-        : VMapEntry(1)
-    {}
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Represents a vertex-normals channel (MODO extension)
- */
-struct NormalChannel : public VMapEntry
-{
-    NormalChannel()
-        : VMapEntry(3)
-    {}
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file texture
- */
-struct Texture
-{
-    // we write the enum values out here to make debugging easier ...
-    enum BlendType
-    {
-        Normal          = 0,
-        Subtractive     = 1,
-        Difference      = 2,
-        Multiply        = 3,
-        Divide          = 4,
-        Alpha           = 5,
-        TextureDispl    = 6,
-        Additive        = 7
-    };
-
-    enum MappingMode
-    {
-        Planar          = 0,
-        Cylindrical     = 1,
-        Spherical       = 2,
-        Cubic           = 3,
-        FrontProjection = 4,
-        UV              = 5
-    };
-
-    enum Axes
-    {
-        AXIS_X          = 0,
-        AXIS_Y          = 1,
-        AXIS_Z          = 2
-    };
-
-    enum Wrap
-    {
-        RESET           = 0,
-        REPEAT          = 1,
-        MIRROR          = 2,
-        EDGE            = 3
-    };
-
-    Texture()
-        : mClipIdx(UINT_MAX)
-        , mStrength         (1.0f)
-        , type()
-        , mUVChannelIndex   ("unknown")
-        , mRealUVIndex      (UINT_MAX)
-        , enabled           (true)
-        , blendType         (Additive)
-        , bCanUse           (true)
-        , mapMode           (UV)
-        , majorAxis         (AXIS_X)
-        , wrapAmountH       (1.0f)
-        , wrapAmountW       (1.0f)
-        , wrapModeWidth     (REPEAT)
-        , wrapModeHeight    (REPEAT)
-        , ordinal           ("\x00")
-    {}
-
-    //! File name of the texture
-    std::string mFileName;
-
-    //! Clip index
-    unsigned int mClipIdx;
-
-    //! Strength of the texture - blend factor
-    float mStrength;
-
-    uint32_t type; // type of the texture
-
-    //! Name of the corresponding UV channel
-    std::string mUVChannelIndex;
-    unsigned int mRealUVIndex;
-
-    //! is the texture enabled?
-    bool enabled;
-
-    //! blend type
-    BlendType blendType;
-
-    //! are we able to use the texture?
-    bool bCanUse;
-
-    //! mapping mode
-    MappingMode mapMode;
-
-    //! major axis for planar, cylindrical, spherical projections
-    Axes majorAxis;
-
-    //! wrap amount for cylindrical and spherical projections
-    float wrapAmountH,wrapAmountW;
-
-    //! wrapping mode for the texture
-    Wrap wrapModeWidth,wrapModeHeight;
-
-    //! ordinal string of the texture
-    std::string ordinal;
-};
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file clip
- */
-struct Clip
-{
-    enum Type
-    {
-         STILL, SEQ, REF, UNSUPPORTED
-    } type;
-
-    Clip()
-        : type   (UNSUPPORTED)
-        , clipRef()
-        , idx    (0)
-        , negate (false)
-    {}
-
-    //! path to the base texture -
-    std::string path;
-
-    //! reference to another CLIP
-    unsigned int clipRef;
-
-    //! index of the clip
-    unsigned int idx;
-
-    //! Negate the clip?
-    bool negate;
-};
-
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file shader
- *
- *  Later
- */
-struct Shader
-{
-    Shader()
-        :   ordinal         ("\x00")
-        ,   functionName    ("unknown")
-        ,   enabled         (true)
-    {}
-
-    std::string ordinal;
-    std::string functionName;
-    bool enabled;
-};
-
-typedef std::list < Texture >       TextureList;
-typedef std::list < Shader >        ShaderList;
-
-// ---------------------------------------------------------------------------
-/** \brief Data structure for a LWO file surface (= material)
- */
-struct Surface
-{
-    Surface()
-        : mColor                (0.78431f,0.78431f,0.78431f)
-        , bDoubleSided          (false)
-        , mDiffuseValue         (1.f)
-        , mSpecularValue        (0.f)
-        , mTransparency         (0.f)
-        , mGlossiness           (0.4f)
-        , mLuminosity           (0.f)
-        , mColorHighlights      (0.f)
-        , mMaximumSmoothAngle   (0.f) // 0 == not specified, no smoothing
-        , mVCMap                ("")
-        , mVCMapType            (AI_LWO_RGBA)
-        , mIOR                  (1.f) // vakuum
-        , mBumpIntensity        (1.f)
-        , mWireframe            (false)
-        , mAdditiveTransparency (0.f)
-    {}
-
-    //! Name of the surface
-    std::string mName;
-
-    //! Color of the surface
-    aiColor3D mColor;
-
-    //! true for two-sided materials
-    bool bDoubleSided;
-
-    //! Various material parameters
-    float mDiffuseValue,mSpecularValue,mTransparency,mGlossiness,mLuminosity,mColorHighlights;
-
-    //! Maximum angle between two adjacent triangles
-    //! that they can be smoothed - in degrees
-    float mMaximumSmoothAngle;
-
-    //! Vertex color map to be used to color the surface
-    std::string mVCMap;
-    uint32_t mVCMapType;
-
-    //! Names of the special shaders to be applied to the surface
-    ShaderList mShaders;
-
-    //! Textures - the first entry in the list is evaluated first
-    TextureList mColorTextures, // color textures are added to both diffuse and specular texture stacks
-        mDiffuseTextures,
-        mSpecularTextures,
-        mOpacityTextures,
-        mBumpTextures,
-        mGlossinessTextures,
-        mReflectionTextures;
-
-    //! Index of refraction
-    float mIOR;
-
-    //! Bump intensity scaling
-    float mBumpIntensity;
-
-    //! Wireframe flag
-    bool mWireframe;
-
-    //! Intensity of additive blending
-    float mAdditiveTransparency;
-};
-
-// ---------------------------------------------------------------------------
-#define AI_LWO_VALIDATE_CHUNK_LENGTH(length,name,size) \
-    if (length < size) \
-    { \
-        throw DeadlyImportError("LWO: "#name" chunk is too small"); \
-    } \
-
-
-// some typedefs ... to make life with loader monsters like this easier
-typedef std::vector <   aiVector3D      >   PointList;
-typedef std::vector <   LWO::Face       >   FaceList;
-typedef std::vector <   LWO::Surface    >   SurfaceList;
-typedef std::vector <   std::string     >   TagList;
-typedef std::vector <   unsigned int    >   TagMappingTable;
-typedef std::vector <   unsigned int    >   ReferrerList;
-typedef std::vector <   WeightChannel   >   WeightChannelList;
-typedef std::vector <   VColorChannel   >   VColorChannelList;
-typedef std::vector <   UVChannel       >   UVChannelList;
-typedef std::vector <   Clip            >   ClipList;
-typedef std::vector <   Envelope        >   EnvelopeList;
-typedef std::vector <   unsigned int    >   SortedRep;
-
-// ---------------------------------------------------------------------------
-/** \brief Represents a layer in the file
- */
-struct Layer
-{
-    Layer()
-        : mFaceIDXOfs   (0)
-        , mPointIDXOfs  (0)
-        , mParent       (0x0)
-        , mIndex        (0xffff)
-        , skip          (false)
-    {}
-
-    /** Temporary point list from the file */
-    PointList mTempPoints;
-
-    /** Lists for every point the index of another point
-        that has been copied from *this* point or UINT_MAX if
-        no copy of the point has been made */
-    ReferrerList mPointReferrers;
-
-    /** Weight channel list from the file */
-    WeightChannelList mWeightChannels;
-
-    /** Subdivision weight channel list from the file */
-    WeightChannelList mSWeightChannels;
-
-    /** Vertex color list from the file */
-    VColorChannelList mVColorChannels;
-
-    /** UV channel list from the file */
-    UVChannelList mUVChannels;
-
-    /** Normal vector channel from the file */
-    NormalChannel mNormals;
-
-    /** Temporary face list from the file*/
-    FaceList mFaces;
-
-    /** Current face indexing offset from the beginning of the buffers*/
-    unsigned int mFaceIDXOfs;
-
-    /** Current point indexing offset from the beginning of the buffers*/
-    unsigned int mPointIDXOfs;
-
-    /** Parent index */
-    uint16_t mParent;
-
-    /** Index of the layer */
-    uint16_t mIndex;
-
-    /** Name of the layer */
-    std::string mName;
-
-    /** Pivot point of the layer */
-    aiVector3D mPivot;
-
-    /** Skip this layer? */
-    bool skip;
-};
-
-typedef std::list<LWO::Layer>       LayerList;
-
-
-}}
-
-
-#endif // !! AI_LWO_FILEDATA_INCLUDED
-
diff --git a/code/MMD/MMDImporter.cpp b/code/MMD/MMDImporter.cpp
deleted file mode 100644
index 3cc618633..000000000
--- a/code/MMD/MMDImporter.cpp
+++ /dev/null
@@ -1,372 +0,0 @@
-/*
----------------------------------------------------------------------------
-Open Asset Import Library (assimp)
----------------------------------------------------------------------------
-
-Copyright (c) 2006-2020, assimp team
-
-All rights reserved.
-
-Redistribution and use of this software in source and binary forms,
-with or without modification, are permitted provided that the following
-conditions are met:
-
-* Redistributions of source code must retain the above
-  copyright notice, this list of conditions and the
-  following disclaimer.
-
-* Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the
-  following disclaimer in the documentation and/or other
-  materials provided with the distribution.
-
-* Neither the name of the assimp team, nor the names of its
-  contributors may be used to endorse or promote products
-  derived from this software without specific prior
-  written permission of the assimp team.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
----------------------------------------------------------------------------
-*/
-
-#ifndef ASSIMP_BUILD_NO_MMD_IMPORTER
-
-#include "MMD/MMDImporter.h"
-#include "MMD/MMDPmdParser.h"
-#include "MMD/MMDPmxParser.h"
-#include "MMD/MMDVmdParser.h"
-#include "PostProcessing/ConvertToLHProcess.h"
-
-#include <assimp/DefaultIOSystem.h>
-#include <assimp/Importer.hpp>
-#include <assimp/ai_assert.h>
-#include <assimp/scene.h>
-
-#include <fstream>
-#include <iomanip>
-#include <memory>
-
-static const aiImporterDesc desc = {"MMD Importer",
-                                    "",
-                                    "",
-                                    "surfaces supported?",
-                                    aiImporterFlags_SupportTextFlavour,
-                                    0,
-                                    0,
-                                    0,
-                                    0,
-                                    "pmx"};
-
-namespace Assimp {
-
-using namespace std;
-
-// ------------------------------------------------------------------------------------------------
-//  Default constructor
-MMDImporter::MMDImporter()
-: m_Buffer()
-, m_strAbsPath("") {
-    DefaultIOSystem io;
-    m_strAbsPath = io.getOsSeparator();
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Destructor.
-MMDImporter::~MMDImporter() {
-    // empty
-}
-
-// ------------------------------------------------------------------------------------------------
-//  Returns true, if file is an pmx file.
-bool MMDImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler,
-                          bool checkSig) const {
-  if (!checkSig) // Check File Extension
-  {
-    return SimpleExtensionCheck(pFile, "pmx");
-  } else // Check file Header
-  {
-    static const char *pTokens[] = {"PMX "};
-    return BaseImporter::SearchFileHeaderForToken(pIOHandler, pFile, pTokens, 1);
-  }
-}
-
-// ------------------------------------------------------------------------------------------------
-const aiImporterDesc *MMDImporter::GetInfo() const { return &desc; }
-
-// ------------------------------------------------------------------------------------------------
-//  MMD import implementation
-void MMDImporter::InternReadFile(const std::string &file, aiScene *pScene,
-                                 IOSystem * /*pIOHandler*/) {
-  // Read file by istream
-  std::filebuf fb;
-  if (!fb.open(file, std::ios::in | std::ios::binary)) {
-    throw DeadlyImportError("Failed to open file " + file + ".");
-  }
-
-  std::istream fileStream(&fb);
-
-  // Get the file-size and validate it, throwing an exception when fails
-  fileStream.seekg(0, fileStream.end);
-  size_t fileSize = static_cast<size_t>(fileStream.tellg());
-  fileStream.seekg(0, fileStream.beg);
-
-  if (fileSize < sizeof(pmx::PmxModel)) {
-    throw DeadlyImportError(file + " is too small.");
-  }
-
-  pmx::PmxModel model;
-  model.Read(&fileStream);
-
-  CreateDataFromImport(&model, pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-void MMDImporter::CreateDataFromImport(const pmx::PmxModel *pModel,
-                                       aiScene *pScene) {
-  if (pModel == NULL) {
-    return;
-  }
-
-  aiNode *pNode = new aiNode;
-  if (!pModel->model_name.empty()) {
-    pNode->mName.Set(pModel->model_name);
-  }
-
-  pScene->mRootNode = pNode;
-
-  pNode = new aiNode;
-  pScene->mRootNode->addChildren(1, &pNode);
-  pNode->mName.Set(string(pModel->model_name) + string("_mesh"));
-
-  // split mesh by materials
-  pNode->mNumMeshes = pModel->material_count;
-  pNode->mMeshes = new unsigned int[pNode->mNumMeshes];
-  for (unsigned int index = 0; index < pNode->mNumMeshes; index++) {
-    pNode->mMeshes[index] = index;
-  }
-
-  pScene->mNumMeshes = pModel->material_count;
-  pScene->mMeshes = new aiMesh *[pScene->mNumMeshes];
-  for (unsigned int i = 0, indexStart = 0; i < pScene->mNumMeshes; i++) {
-    const int indexCount = pModel->materials[i].index_count;
-
-    pScene->mMeshes[i] = CreateMesh(pModel, indexStart, indexCount);
-    pScene->mMeshes[i]->mName = pModel->materials[i].material_name;
-    pScene->mMeshes[i]->mMaterialIndex = i;
-    indexStart += indexCount;
-  }
-
-  // create node hierarchy for bone position
-  std::unique_ptr<aiNode *[]> ppNode(new aiNode *[pModel->bone_count]);
-  for (auto i = 0; i < pModel->bone_count; i++) {
-    ppNode[i] = new aiNode(pModel->bones[i].bone_name);
-  }
-
-  for (auto i = 0; i < pModel->bone_count; i++) {
-    const pmx::PmxBone &bone = pModel->bones[i];
-
-    if (bone.parent_index < 0) {
-      pScene->mRootNode->addChildren(1, ppNode.get() + i);
-    } else {
-      ppNode[bone.parent_index]->addChildren(1, ppNode.get() + i);
-
-      aiVector3D v3 = aiVector3D(
-          bone.position[0] - pModel->bones[bone.parent_index].position[0],
-          bone.position[1] - pModel->bones[bone.parent_index].position[1],
-          bone.position[2] - pModel->bones[bone.parent_index].position[2]);
-      aiMatrix4x4::Translation(v3, ppNode[i]->mTransformation);
-    }
-  }
-
-  // create materials
-  pScene->mNumMaterials = pModel->material_count;
-  pScene->mMaterials = new aiMaterial *[pScene->mNumMaterials];
-  for (unsigned int i = 0; i < pScene->mNumMaterials; i++) {
-    pScene->mMaterials[i] = CreateMaterial(&pModel->materials[i], pModel);
-  }
-
-  // Convert everything to OpenGL space
-  MakeLeftHandedProcess convertProcess;
-  convertProcess.Execute(pScene);
-
-  FlipUVsProcess uvFlipper;
-  uvFlipper.Execute(pScene);
-
-  FlipWindingOrderProcess windingFlipper;
-  windingFlipper.Execute(pScene);
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMesh *MMDImporter::CreateMesh(const pmx::PmxModel *pModel,
-                                const int indexStart, const int indexCount) {
-  aiMesh *pMesh = new aiMesh;
-
-  pMesh->mNumVertices = indexCount;
-
-  pMesh->mNumFaces = indexCount / 3;
-  pMesh->mFaces = new aiFace[pMesh->mNumFaces];
-
-  const int numIndices = 3; // triangular face
-  for (unsigned int index = 0; index < pMesh->mNumFaces; index++) {
-    pMesh->mFaces[index].mNumIndices = numIndices;
-    unsigned int *indices = new unsigned int[numIndices];
-    indices[0] = numIndices * index;
-    indices[1] = numIndices * index + 1;
-    indices[2] = numIndices * index + 2;
-    pMesh->mFaces[index].mIndices = indices;
-  }
-
-  pMesh->mVertices = new aiVector3D[pMesh->mNumVertices];
-  pMesh->mNormals = new aiVector3D[pMesh->mNumVertices];
-  pMesh->mTextureCoords[0] = new aiVector3D[pMesh->mNumVertices];
-  pMesh->mNumUVComponents[0] = 2;
-
-  // additional UVs
-  for (int i = 1; i <= pModel->setting.uv; i++) {
-    pMesh->mTextureCoords[i] = new aiVector3D[pMesh->mNumVertices];
-    pMesh->mNumUVComponents[i] = 4;
-  }
-
-  map<int, vector<aiVertexWeight>> bone_vertex_map;
-
-  // fill in contents and create bones
-  for (int index = 0; index < indexCount; index++) {
-    const pmx::PmxVertex *v =
-        &pModel->vertices[pModel->indices[indexStart + index]];
-    const float *position = v->position;
-    pMesh->mVertices[index].Set(position[0], position[1], position[2]);
-    const float *normal = v->normal;
-
-    pMesh->mNormals[index].Set(normal[0], normal[1], normal[2]);
-    pMesh->mTextureCoords[0][index].x = v->uv[0];
-    pMesh->mTextureCoords[0][index].y = v->uv[1];
-
-    for (int i = 1; i <= pModel->setting.uv; i++) {
-      // TODO: wrong here? use quaternion transform?
-      pMesh->mTextureCoords[i][index].x = v->uva[i][0];
-      pMesh->mTextureCoords[i][index].y = v->uva[i][1];
-    }
-
-    // handle bone map
-    const auto vsBDEF1_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningBDEF1 *>(v->skinning.get());
-    const auto vsBDEF2_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningBDEF2 *>(v->skinning.get());
-    const auto vsBDEF4_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningBDEF4 *>(v->skinning.get());
-    const auto vsSDEF_ptr =
-        dynamic_cast<pmx::PmxVertexSkinningSDEF *>(v->skinning.get());
-    switch (v->skinning_type) {
-    case pmx::PmxVertexSkinningType::BDEF1:
-      bone_vertex_map[vsBDEF1_ptr->bone_index].push_back(
-          aiVertexWeight(index, 1.0));
-      break;
-    case pmx::PmxVertexSkinningType::BDEF2:
-      bone_vertex_map[vsBDEF2_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsBDEF2_ptr->bone_weight));
-      bone_vertex_map[vsBDEF2_ptr->bone_index2].push_back(
-          aiVertexWeight(index, 1.0f - vsBDEF2_ptr->bone_weight));
-      break;
-    case pmx::PmxVertexSkinningType::BDEF4:
-      bone_vertex_map[vsBDEF4_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight1));
-      bone_vertex_map[vsBDEF4_ptr->bone_index2].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight2));
-      bone_vertex_map[vsBDEF4_ptr->bone_index3].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight3));
-      bone_vertex_map[vsBDEF4_ptr->bone_index4].push_back(
-          aiVertexWeight(index, vsBDEF4_ptr->bone_weight4));
-      break;
-    case pmx::PmxVertexSkinningType::SDEF: // TODO: how to use sdef_c, sdef_r0,
-                                           // sdef_r1?
-      bone_vertex_map[vsSDEF_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsSDEF_ptr->bone_weight));
-      bone_vertex_map[vsSDEF_ptr->bone_index2].push_back(
-          aiVertexWeight(index, 1.0f - vsSDEF_ptr->bone_weight));
-      break;
-    case pmx::PmxVertexSkinningType::QDEF:
-      const auto vsQDEF_ptr =
-          dynamic_cast<pmx::PmxVertexSkinningQDEF *>(v->skinning.get());
-      bone_vertex_map[vsQDEF_ptr->bone_index1].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight1));
-      bone_vertex_map[vsQDEF_ptr->bone_index2].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight2));
-      bone_vertex_map[vsQDEF_ptr->bone_index3].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight3));
-      bone_vertex_map[vsQDEF_ptr->bone_index4].push_back(
-          aiVertexWeight(index, vsQDEF_ptr->bone_weight4));
-      break;
-    }
-  }
-
-  // make all bones for each mesh
-  // assign bone weights to skinned bones (otherwise just initialize)
-  auto bone_ptr_ptr = new aiBone *[pModel->bone_count];
-  pMesh->mNumBones = pModel->bone_count;
-  pMesh->mBones = bone_ptr_ptr;
-  for (auto ii = 0; ii < pModel->bone_count; ++ii) {
-    auto pBone = new aiBone;
-    const auto &pmxBone = pModel->bones[ii];
-    pBone->mName = pmxBone.bone_name;
-    aiVector3D pos(pmxBone.position[0], pmxBone.position[1], pmxBone.position[2]);
-    aiMatrix4x4::Translation(-pos, pBone->mOffsetMatrix);
-    auto it = bone_vertex_map.find(ii);
-    if (it != bone_vertex_map.end()) {
-      pBone->mNumWeights = static_cast<unsigned int>(it->second.size());
-      pBone->mWeights = new aiVertexWeight[pBone->mNumWeights];
-      for (unsigned int j = 0; j < pBone->mNumWeights; j++) {
-          pBone->mWeights[j] = it->second[j];
-      }
-    }
-    bone_ptr_ptr[ii] = pBone;
-  }
-
-  return pMesh;
-}
-
-// ------------------------------------------------------------------------------------------------
-aiMaterial *MMDImporter::CreateMaterial(const pmx::PmxMaterial *pMat,
-                                        const pmx::PmxModel *pModel) {
-  aiMaterial *mat = new aiMaterial();
-  aiString name(pMat->material_english_name);
-  mat->AddProperty(&name, AI_MATKEY_NAME);
-
-  aiColor3D diffuse(pMat->diffuse[0], pMat->diffuse[1], pMat->diffuse[2]);
-  mat->AddProperty(&diffuse, 1, AI_MATKEY_COLOR_DIFFUSE);
-  aiColor3D specular(pMat->specular[0], pMat->specular[1], pMat->specular[2]);
-  mat->AddProperty(&specular, 1, AI_MATKEY_COLOR_SPECULAR);
-  aiColor3D ambient(pMat->ambient[0], pMat->ambient[1], pMat->ambient[2]);
-  mat->AddProperty(&ambient, 1, AI_MATKEY_COLOR_AMBIENT);
-
-  float opacity = pMat->diffuse[3];
-  mat->AddProperty(&opacity, 1, AI_MATKEY_OPACITY);
-  float shininess = pMat->specularlity;
-  mat->AddProperty(&shininess, 1, AI_MATKEY_SHININESS_STRENGTH);
-
-  if(pMat->diffuse_texture_index >= 0) {
-      aiString texture_path(pModel->textures[pMat->diffuse_texture_index]);
-      mat->AddProperty(&texture_path, AI_MATKEY_TEXTURE(aiTextureType_DIFFUSE, 0));
-  }
-
-  int mapping_uvwsrc = 0;
-  mat->AddProperty(&mapping_uvwsrc, 1,
-                   AI_MATKEY_UVWSRC(aiTextureType_DIFFUSE, 0));
-
-  return mat;
-}
-
-// ------------------------------------------------------------------------------------------------
-
-} // Namespace Assimp
-
-#endif // !! ASSIMP_BUILD_NO_MMD_IMPORTER
diff --git a/include/assimp/Exceptional.h b/include/assimp/Exceptional.h
index dcd5e2b2e..8970ade7c 100644
--- a/include/assimp/Exceptional.h
+++ b/include/assimp/Exceptional.h
@@ -66,10 +66,16 @@ public:
     : runtime_error(errorText) {
         // empty
     }
-
 };
 
-typedef DeadlyImportError DeadlyExportError;
+class DeadlyExportError : public runtime_error {
+public:
+    /** Constructor with arguments */
+    explicit DeadlyExportError(const std::string &errorText) :
+            runtime_error(errorText) {
+        // empty
+    }
+};
 
 #ifdef _MSC_VER
 #   pragma warning(default : 4275)
diff --git a/include/assimp/ai_assert.h b/include/assimp/ai_assert.h
index f430e4ad3..f018163bf 100644
--- a/include/assimp/ai_assert.h
+++ b/include/assimp/ai_assert.h
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/include/assimp/anim.h b/include/assimp/anim.h
index 7ef5355e6..b43991b80 100644
--- a/include/assimp/anim.h
+++ b/include/assimp/anim.h
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
diff --git a/include/assimp/cexport.h b/include/assimp/cexport.h
index 959d4377e..badfd0a6f 100644
--- a/include/assimp/cexport.h
+++ b/include/assimp/cexport.h
@@ -47,42 +47,42 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_EXPORT_H_INC
 
 #ifdef __GNUC__
-#   pragma GCC system_header
+#pragma GCC system_header
 #endif
 
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
-// Public ASSIMP data structures
 #include <assimp/types.h>
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-struct aiScene;  // aiScene.h
-struct aiFileIO; // aiFileIO.h
+struct aiScene;
+struct aiFileIO;
 
 // --------------------------------------------------------------------------------
-/** Describes an file format which Assimp can export to. Use #aiGetExportFormatCount() to
-* learn how many export formats the current Assimp build supports and #aiGetExportFormatDescription()
-* to retrieve a description of an export format option.
-*/
-struct aiExportFormatDesc
-{
+/**
+ *  @brief  Describes an file format which Assimp can export to.
+ *
+ *  Use #aiGetExportFormatCount() to learn how many export-formats are supported by
+ *  the current Assimp-build and #aiGetExportFormatDescription() to retrieve the
+ *  description of the export format option.
+ */
+struct aiExportFormatDesc {
     /// a short string ID to uniquely identify the export format. Use this ID string to
     /// specify which file format you want to export to when calling #aiExportScene().
     /// Example: "dae" or "obj"
-    const char* id;
+    const char *id;
 
     /// A short description of the file format to present to users. Useful if you want
     /// to allow the user to select an export format.
-    const char* description;
+    const char *description;
 
     /// Recommended file extension for the exported file in lower case.
-    const char* fileExtension;
+    const char *fileExtension;
 };
 
-
 // --------------------------------------------------------------------------------
 /** Returns the number of export file formats available in the current Assimp build.
  * Use aiGetExportFormatDescription() to retrieve infos of a specific export format.
@@ -97,14 +97,14 @@ ASSIMP_API size_t aiGetExportFormatCount(void);
  *    0 to #aiGetExportFormatCount()
  * @return A description of that specific export format. NULL if pIndex is out of range.
  */
-ASSIMP_API const C_STRUCT aiExportFormatDesc* aiGetExportFormatDescription( size_t pIndex);
+ASSIMP_API const C_STRUCT aiExportFormatDesc *aiGetExportFormatDescription(size_t pIndex);
 
 // --------------------------------------------------------------------------------
 /** Release a description of the nth export file format. Must be returned by
 * aiGetExportFormatDescription
 * @param desc Pointer to the description
 */
-ASSIMP_API void aiReleaseExportFormatDescription( const C_STRUCT aiExportFormatDesc *desc );
+ASSIMP_API void aiReleaseExportFormatDescription(const C_STRUCT aiExportFormatDesc *desc);
 
 // --------------------------------------------------------------------------------
 /** Create a modifiable copy of a scene.
@@ -115,13 +115,12 @@ ASSIMP_API void aiReleaseExportFormatDescription( const C_STRUCT aiExportFormatD
  *  @param pOut Receives a modifyable copy of the scene. Use aiFreeScene() to
  *    delete it again.
  */
-ASSIMP_API void aiCopyScene(const C_STRUCT aiScene* pIn,
-    C_STRUCT aiScene** pOut);
-
+ASSIMP_API void aiCopyScene(const C_STRUCT aiScene *pIn,
+        C_STRUCT aiScene **pOut);
 
 // --------------------------------------------------------------------------------
 /** Frees a scene copy created using aiCopyScene() */
-ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
+ASSIMP_API void aiFreeScene(const C_STRUCT aiScene *pIn);
 
 // --------------------------------------------------------------------------------
 /** Exports the given scene to a chosen file format and writes the result file(s) to disk.
@@ -154,19 +153,18 @@ ASSIMP_API void aiFreeScene(const C_STRUCT aiScene* pIn);
 *   triangulate data so they would run the step anyway.
 *
 *   If assimp detects that the input scene was directly taken from the importer side of
-*   the library (i.e. not copied using aiCopyScene and potetially modified afterwards),
-*   any postprocessing steps already applied to the scene will not be applied again, unless
-*   they show non-idempotent behaviour (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
+*   the library (i.e. not copied using aiCopyScene and potentially modified afterwards),
+*   any post-processing steps already applied to the scene will not be applied again, unless
+*   they show non-idempotent behavior (#aiProcess_MakeLeftHanded, #aiProcess_FlipUVs and
 *   #aiProcess_FlipWindingOrder).
 * @return a status code indicating the result of the export
 * @note Use aiCopyScene() to get a modifiable copy of a previously
 *   imported scene.
 */
-ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
-    const char* pFormatId,
-    const char* pFileName,
-    unsigned int pPreprocessing);
-
+ASSIMP_API aiReturn aiExportScene(const C_STRUCT aiScene *pScene,
+        const char *pFormatId,
+        const char *pFileName,
+        unsigned int pPreprocessing);
 
 // --------------------------------------------------------------------------------
 /** Exports the given scene to a chosen file format using custom IO logic supplied by you.
@@ -183,11 +181,11 @@ ASSIMP_API aiReturn aiExportScene( const C_STRUCT aiScene* pScene,
 * @note Use aiCopyScene() to get a modifiable copy of a previously
 *   imported scene.
 */
-ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
-    const char* pFormatId,
-    const char* pFileName,
-    C_STRUCT aiFileIO* pIO,
-    unsigned int pPreprocessing );
+ASSIMP_API aiReturn aiExportSceneEx(const C_STRUCT aiScene *pScene,
+        const char *pFormatId,
+        const char *pFileName,
+        C_STRUCT aiFileIO *pIO,
+        unsigned int pPreprocessing);
 
 // --------------------------------------------------------------------------------
 /** Describes a blob of exported scene data. Use #aiExportSceneToBlob() to create a blob containing an
@@ -199,13 +197,12 @@ ASSIMP_API aiReturn aiExportSceneEx( const C_STRUCT aiScene* pScene,
 * This is used when exporters write more than one output file for a given #aiScene. See the remarks for
 * #aiExportDataBlob::name for more information.
 */
-struct aiExportDataBlob
-{
+struct aiExportDataBlob {
     /// Size of the data in bytes
     size_t size;
 
     /// The data.
-    void* data;
+    void *data;
 
     /** Name of the blob. An empty string always
         indicates the first (and primary) blob,
@@ -222,18 +219,23 @@ struct aiExportDataBlob
     C_STRUCT aiString name;
 
     /** Pointer to the next blob in the chain or NULL if there is none. */
-    C_STRUCT aiExportDataBlob * next;
+    C_STRUCT aiExportDataBlob *next;
 
 #ifdef __cplusplus
     /// Default constructor
-    aiExportDataBlob() { size = 0; data = next = NULL; }
+    aiExportDataBlob() {
+        size = 0;
+        data = next = nullptr;
+    }
     /// Releases the data
-    ~aiExportDataBlob() { delete [] static_cast<unsigned char*>( data ); delete next; }
+    ~aiExportDataBlob() {
+        delete[] static_cast<unsigned char *>(data);
+        delete next;
+    }
+
+    aiExportDataBlob(const aiExportDataBlob &) = delete;
+    aiExportDataBlob &operator=(const aiExportDataBlob &) = delete;
 
-private:
-    // no copying
-    aiExportDataBlob(const aiExportDataBlob& );
-    aiExportDataBlob& operator= (const aiExportDataBlob& );
 #endif // __cplusplus
 };
 
@@ -247,15 +249,15 @@ private:
 * @param pPreprocessing Please see the documentation for #aiExportScene
 * @return the exported data or NULL in case of error
 */
-ASSIMP_API const C_STRUCT aiExportDataBlob* aiExportSceneToBlob( const C_STRUCT aiScene* pScene, const char* pFormatId,
-    unsigned int pPreprocessing );
+ASSIMP_API const C_STRUCT aiExportDataBlob *aiExportSceneToBlob(const C_STRUCT aiScene *pScene, const char *pFormatId,
+        unsigned int pPreprocessing);
 
 // --------------------------------------------------------------------------------
 /** Releases the memory associated with the given exported data. Use this function to free a data blob
 * returned by aiExportScene().
 * @param pData the data blob returned by #aiExportSceneToBlob
 */
-ASSIMP_API void aiReleaseExportBlob( const C_STRUCT aiExportDataBlob* pData );
+ASSIMP_API void aiReleaseExportBlob(const C_STRUCT aiExportDataBlob *pData);
 
 #ifdef __cplusplus
 }
diff --git a/test/unit/ImportExport/MDL/utMDLImporter_HL1_ImportSettings.cpp b/test/unit/ImportExport/MDL/utMDLImporter_HL1_ImportSettings.cpp
index fcef79cff..e9af1245b 100644
--- a/test/unit/ImportExport/MDL/utMDLImporter_HL1_ImportSettings.cpp
+++ b/test/unit/ImportExport/MDL/utMDLImporter_HL1_ImportSettings.cpp
@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "AbstractImportExportBase.h"
-#include "MDL/HalfLife/HL1ImportDefinitions.h"
+#include "AssetLib/MDL/HalfLife/HL1ImportDefinitions.h"
 #include "MDLHL1TestFiles.h"
 #include "UnitTestPCH.h"
 #include <assimp/postprocess.h>
diff --git a/test/unit/ImportExport/MDL/utMDLImporter_HL1_Materials.cpp b/test/unit/ImportExport/MDL/utMDLImporter_HL1_Materials.cpp
index 142c37ebb..43ff6f486 100644
--- a/test/unit/ImportExport/MDL/utMDLImporter_HL1_Materials.cpp
+++ b/test/unit/ImportExport/MDL/utMDLImporter_HL1_Materials.cpp
@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "AbstractImportExportBase.h"
-#include "MDL/HalfLife/HL1ImportDefinitions.h"
+#include "AssetLib/MDL/HalfLife/HL1ImportDefinitions.h"
 #include "MDLHL1TestFiles.h"
 #include "UnitTestPCH.h"
 #include <assimp/postprocess.h>
diff --git a/test/unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp b/test/unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp
index e39aa5a29..67223497f 100644
--- a/test/unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp
+++ b/test/unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp
@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "AbstractImportExportBase.h"
-#include "MDL/HalfLife/HL1ImportDefinitions.h"
+#include "AssetLib/MDL/HalfLife/HL1ImportDefinitions.h"
 #include "MDLHL1TestFiles.h"
 #include "UnitTestPCH.h"
 #include <assimp/postprocess.h>
diff --git a/test/unit/utBlenderIntermediate.cpp b/test/unit/utBlenderIntermediate.cpp
index da8d3f156..b06dc8893 100644
--- a/test/unit/utBlenderIntermediate.cpp
+++ b/test/unit/utBlenderIntermediate.cpp
@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 #include "UnitTestPCH.h"
-#include "Blender/BlenderIntermediate.h"
+#include "AssetLib/Blender/BlenderIntermediate.h"
 #include <assimp/camera.h>
 #include <assimp/light.h>
 #include <assimp/mesh.h>
diff --git a/test/unit/utD3MFImportExport.cpp b/test/unit/utD3MFImportExport.cpp
index 53d5e82c1..f252ecfb4 100644
--- a/test/unit/utD3MFImportExport.cpp
+++ b/test/unit/utD3MFImportExport.cpp
@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/Exporter.hpp>
 #include <assimp/Importer.hpp>
 
-#include "3MF/D3MFExporter.h"
+#include "AssetLib/3MF/D3MFExporter.h"
 
 class utD3MFImporterExporter : public AbstractImportExportBase {
 public:
diff --git a/test/unit/utObjTools.cpp b/test/unit/utObjTools.cpp
index d1d35e7e8..505123eb7 100644
--- a/test/unit/utObjTools.cpp
+++ b/test/unit/utObjTools.cpp
@@ -38,8 +38,8 @@ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
-#include "Obj/ObjFileParser.h"
-#include "Obj/ObjTools.h"
+#include "AssetLib/Obj/ObjFileParser.h"
+#include "AssetLib/Obj/ObjTools.h"
 #include "UnitTestPCH.h"
 
 using namespace ::Assimp;
diff --git a/test/unit/utPMXImporter.cpp b/test/unit/utPMXImporter.cpp
index 5ab7a9d6a..d1b5f0fcf 100644
--- a/test/unit/utPMXImporter.cpp
+++ b/test/unit/utPMXImporter.cpp
@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "UnitTestPCH.h"
 #include "AbstractImportExportBase.h"
-#include "MMD/MMDImporter.h"
+#include "AssetLib/MMD/MMDImporter.h"
 
 #include <assimp/Importer.hpp>
 
diff --git a/test/unit/utSIBImporter.cpp b/test/unit/utSIBImporter.cpp
index 3224ee8da..03e849351 100644
--- a/test/unit/utSIBImporter.cpp
+++ b/test/unit/utSIBImporter.cpp
@@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #include "UnitTestPCH.h"
 
-#include "SIB/SIBImporter.h"
+#include "AssetLib/SIB/SIBImporter.h"
 
 #include <assimp/postprocess.h>
 #include <assimp/Importer.hpp>
diff --git a/test/unit/utSMDImportExport.cpp b/test/unit/utSMDImportExport.cpp
index 64e67a22f..8668e8a5a 100644
--- a/test/unit/utSMDImportExport.cpp
+++ b/test/unit/utSMDImportExport.cpp
@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "UnitTestPCH.h"
 
 #include "AbstractImportExportBase.h"
-#include "SMD/SMDLoader.h"
+#include "AssetLib/SMD/SMDLoader.h"
 #include <assimp/postprocess.h>
 #include <assimp/Importer.hpp>
 
diff --git a/tools/assimp_cmd/WriteDump.cpp b/tools/assimp_cmd/WriteDump.cpp
index a19bab958..6d73d1f76 100644
--- a/tools/assimp_cmd/WriteDump.cpp
+++ b/tools/assimp_cmd/WriteDump.cpp
@@ -58,8 +58,8 @@ const char *AICMD_MSG_DUMP_HELP =
 
 #include "Common/assbin_chunks.h"
 #include <assimp/DefaultIOSystem.h>
-#include <code/Assbin/AssbinFileWriter.h>
-#include <code/Assxml/AssxmlFileWriter.h>
+#include "AssetLib/Assbin/AssbinFileWriter.h"
+#include "AssetLib/Assxml/AssxmlFileWriter.h"
 
 #include <memory>
 
diff --git a/tools/assimp_view/Background.cpp b/tools/assimp_view/Background.cpp
index d1db3b60a..3cf0a81e3 100644
--- a/tools/assimp_view/Background.cpp
+++ b/tools/assimp_view/Background.cpp
@@ -51,135 +51,143 @@ extern std::string g_szSkyboxShader;
 /** \brief Vertex structure for the skybox
 */
 // ------------------------------------------------------------------------------
-struct SkyBoxVertex
-{
-    float x,y,z;
-    float u,v,w;
+struct SkyBoxVertex {
+    float x, y, z;
+    float u, v, w;
 };
 
-
 // ------------------------------------------------------------------------------
 /** \brief Vertices for the skybox
 */
 // ------------------------------------------------------------------------------
-SkyBoxVertex g_cubeVertices_indexed[] =
-{
-    { -1.0f, 1.0f, -1.0f,   -1.0f,1.0f,-1.0f },     // 0
-    { 1.0f, 1.0f,  -1.0f,   1.0f,1.0f,-1.0f },      // 1
-    { -1.0f, -1.0f, -1.0f,  -1.0f,-1.0f,-1.0f },    // 2
-    { 1.0f,-1.0f,-1.0f,      1.0f,-1.0f,-1.0f },    // 3
-    {-1.0f, 1.0f, 1.0f,     -1.0f,1.0f,1.0f },      // 4
-    {-1.0f,-1.0f, 1.0f,     -1.0f,-1.0f,1.0f },     // 5
-    { 1.0f, 1.0f, 1.0f,     1.0f,1.0f,1.0f },       // 6
-    { 1.0f,-1.0f, 1.0f,     1.0f,-1.0f,1.0f }       // 7
+SkyBoxVertex g_cubeVertices_indexed[] = {
+    { -1.0f, 1.0f, -1.0f, -1.0f, 1.0f, -1.0f }, // 0
+    { 1.0f, 1.0f, -1.0f, 1.0f, 1.0f, -1.0f }, // 1
+    { -1.0f, -1.0f, -1.0f, -1.0f, -1.0f, -1.0f }, // 2
+    { 1.0f, -1.0f, -1.0f, 1.0f, -1.0f, -1.0f }, // 3
+    { -1.0f, 1.0f, 1.0f, -1.0f, 1.0f, 1.0f }, // 4
+    { -1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 1.0f }, // 5
+    { 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f }, // 6
+    { 1.0f, -1.0f, 1.0f, 1.0f, -1.0f, 1.0f } // 7
 };
 
-
 // ------------------------------------------------------------------------------
 /** \brief Indices for the skybox
 */
 // ------------------------------------------------------------------------------
-unsigned short g_cubeIndices[] =
-{
-    0, 1, 2, 3, 2, 1,4, 5, 6,
-    7, 6, 5, 4, 6,  0, 1, 6, 0,
-    5, 2, 7,3, 2, 7, 1, 6, 3,
-    7, 3, 6, 0, 2, 4, 5, 4, 2,
+unsigned short g_cubeIndices[] = {
+    0,
+    1,
+    2,
+    3,
+    2,
+    1,
+    4,
+    5,
+    6,
+    7,
+    6,
+    5,
+    4,
+    6,
+    0,
+    1,
+    6,
+    0,
+    5,
+    2,
+    7,
+    3,
+    2,
+    7,
+    1,
+    6,
+    3,
+    7,
+    3,
+    6,
+    0,
+    2,
+    4,
+    5,
+    4,
+    2,
 };
 
 CBackgroundPainter CBackgroundPainter::s_cInstance;
 
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::SetColor (D3DCOLOR p_clrNew)
-{
+void CBackgroundPainter::SetColor(D3DCOLOR p_clrNew) {
     if (TEXTURE_CUBE == eMode)
         RemoveSBDeps();
 
     clrColor = p_clrNew;
     eMode = SIMPLE_COLOR;
 
-    if (pcTexture)
-    {
+    if (pcTexture) {
         pcTexture->Release();
         pcTexture = nullptr;
     }
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::RemoveSBDeps()
-{
+void CBackgroundPainter::RemoveSBDeps() {
     MODE e = eMode;
     eMode = SIMPLE_COLOR;
-    if (g_pcAsset && g_pcAsset->pcScene)
-    {
-        for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-        {
-            if (aiShadingMode_Gouraud != g_pcAsset->apcMeshes[i]->eShadingMode)
-            {
+    if (g_pcAsset && g_pcAsset->pcScene) {
+        for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i) {
+            if (aiShadingMode_Gouraud != g_pcAsset->apcMeshes[i]->eShadingMode) {
                 CMaterialManager::Instance().DeleteMaterial(g_pcAsset->apcMeshes[i]);
                 CMaterialManager::Instance().CreateMaterial(
-                    g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]);
+                        g_pcAsset->apcMeshes[i], g_pcAsset->pcScene->mMeshes[i]);
             }
         }
     }
     eMode = e;
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::ResetSB()
-{
+void CBackgroundPainter::ResetSB() {
     mMatrix = aiMatrix4x4();
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::SetCubeMapBG (const char* p_szPath)
-{
+void CBackgroundPainter::SetCubeMapBG(const char *p_szPath) {
     bool bHad = false;
-    if (pcTexture)
-    {
+    if (pcTexture) {
         pcTexture->Release();
         pcTexture = nullptr;
-        if(TEXTURE_CUBE ==eMode)bHad = true;
+        if (TEXTURE_CUBE == eMode) bHad = true;
     }
 
     eMode = TEXTURE_CUBE;
 
-    szPath = std::string( p_szPath );
+    szPath = std::string(p_szPath);
 
     // ARRRGHH... ugly. TODO: Rewrite this!
     aiString sz;
     sz.Set(szPath);
     CMaterialManager::Instance().FindValidPath(&sz);
-    szPath = std::string( sz.data );
+    szPath = std::string(sz.data);
 
     // now recreate all native resources
     RecreateNativeResource();
 
-    if (SIMPLE_COLOR != this->eMode)
-    {
+    if (SIMPLE_COLOR != this->eMode) {
         // this influences all material with specular components
-        if (!bHad)
-        {
-            if (g_pcAsset && g_pcAsset->pcScene)
-            {
-                for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-                {
-                    if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode)
-                    {
+        if (!bHad) {
+            if (g_pcAsset && g_pcAsset->pcScene) {
+                for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i) {
+                    if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode) {
                         CMaterialManager::Instance().DeleteMaterial(g_pcAsset->apcMeshes[i]);
                         CMaterialManager::Instance().CreateMaterial(
-                            g_pcAsset->apcMeshes[i],g_pcAsset->pcScene->mMeshes[i]);
+                                g_pcAsset->apcMeshes[i], g_pcAsset->pcScene->mMeshes[i]);
                     }
                 }
             }
-        }
-        else
-        {
-            if (g_pcAsset && g_pcAsset->pcScene)
-            {
-                for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes;++i)
-                {
-                    if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode)
-                    {
+        } else {
+            if (g_pcAsset && g_pcAsset->pcScene) {
+                for (unsigned int i = 0; i < g_pcAsset->pcScene->mNumMeshes; ++i) {
+                    if (aiShadingMode_Phong == g_pcAsset->apcMeshes[i]->eShadingMode) {
                         g_pcAsset->apcMeshes[i]->piEffect->SetTexture(
-                            "lw_tex_envmap",CBackgroundPainter::Instance().GetTexture());
+                                "lw_tex_envmap", CBackgroundPainter::Instance().GetTexture());
                     }
                 }
             }
@@ -187,64 +195,54 @@ void CBackgroundPainter::SetCubeMapBG (const char* p_szPath)
     }
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::RotateSB(const aiMatrix4x4* pm)
-{
+void CBackgroundPainter::RotateSB(const aiMatrix4x4 *pm) {
     this->mMatrix = mMatrix * (*pm);
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::SetTextureBG (const char* p_szPath)
-{
-    if (TEXTURE_CUBE == this->eMode)this->RemoveSBDeps();
+void CBackgroundPainter::SetTextureBG(const char *p_szPath) {
+    if (TEXTURE_CUBE == this->eMode) this->RemoveSBDeps();
 
-    if (pcTexture)
-    {
+    if (pcTexture) {
         pcTexture->Release();
         pcTexture = nullptr;
     }
 
     eMode = TEXTURE_2D;
-    szPath = std::string( p_szPath );
+    szPath = std::string(p_szPath);
 
     // ARRRGHH... ugly. TODO: Rewrite this!
     aiString sz;
     sz.Set(szPath);
     CMaterialManager::Instance().FindValidPath(&sz);
-    szPath = std::string( sz.data );
+    szPath = std::string(sz.data);
 
     // now recreate all native resources
     RecreateNativeResource();
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::OnPreRender()
-{
-    if (SIMPLE_COLOR != eMode)
-    {
+void CBackgroundPainter::OnPreRender() {
+    if (SIMPLE_COLOR != eMode) {
         // clear the z-buffer only (in wireframe mode we must also clear
         // the color buffer )
-        if (g_sOptions.eDrawMode == RenderOptions::WIREFRAME)
-        {
-            g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET,
-                D3DCOLOR_ARGB(0xff,100,100,100),1.0f,0);
-        }
-        else
-        {
-            g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER,0,1.0f,0);
+        if (g_sOptions.eDrawMode == RenderOptions::WIREFRAME) {
+            g_piDevice->Clear(0, nullptr, D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET,
+                    D3DCOLOR_ARGB(0xff, 100, 100, 100), 1.0f, 0);
+        } else {
+            g_piDevice->Clear(0, nullptr, D3DCLEAR_ZBUFFER, 0, 1.0f, 0);
         }
 
-        if (TEXTURE_2D == eMode)
-        {
+        if (TEXTURE_2D == eMode) {
             RECT sRect;
-            GetWindowRect(GetDlgItem(g_hDlg,IDC_RT),&sRect);
+            GetWindowRect(GetDlgItem(g_hDlg, IDC_RT), &sRect);
             sRect.right -= sRect.left;
             sRect.bottom -= sRect.top;
 
-            struct SVertex
-            {
-                float x,y,z,w,u,v;
+            struct SVertex {
+                float x, y, z, w, u, v;
             };
 
             UINT dw;
-            this->piSkyBoxEffect->Begin(&dw,0);
+            this->piSkyBoxEffect->Begin(&dw, 0);
             this->piSkyBoxEffect->BeginPass(0);
 
             SVertex as[4];
@@ -276,14 +274,21 @@ void CBackgroundPainter::OnPreRender()
             as[2].u = 1.0f;
             as[2].v = 1.0f;
 
-            as[0].x -= 0.5f;as[1].x -= 0.5f;as[2].x -= 0.5f;as[3].x -= 0.5f;
-            as[0].y -= 0.5f;as[1].y -= 0.5f;as[2].y -= 0.5f;as[3].y -= 0.5f;
+            as[0].x -= 0.5f;
+            as[1].x -= 0.5f;
+            as[2].x -= 0.5f;
+            as[3].x -= 0.5f;
+            as[0].y -= 0.5f;
+            as[1].y -= 0.5f;
+            as[2].y -= 0.5f;
+            as[3].y -= 0.5f;
 
-            DWORD dw2;g_piDevice->GetFVF(&dw2);
+            DWORD dw2;
+            g_piDevice->GetFVF(&dw2);
             g_piDevice->SetFVF(D3DFVF_XYZRHW | D3DFVF_TEX1);
 
-            g_piDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP,2,
-                &as,sizeof(SVertex));
+            g_piDevice->DrawPrimitiveUP(D3DPT_TRIANGLESTRIP, 2,
+                    &as, sizeof(SVertex));
 
             piSkyBoxEffect->EndPass();
             piSkyBoxEffect->End();
@@ -293,14 +298,12 @@ void CBackgroundPainter::OnPreRender()
         return;
     }
     // clear both the render target and the z-buffer
-    g_piDevice->Clear(0,nullptr,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
-        clrColor,1.0f,0);
+    g_piDevice->Clear(0, nullptr, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
+            clrColor, 1.0f, 0);
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::OnPostRender()
-{
-    if (TEXTURE_CUBE == eMode)
-    {
+void CBackgroundPainter::OnPostRender() {
+    if (TEXTURE_CUBE == eMode) {
         aiMatrix4x4 pcProj;
         GetProjectionMatrix(pcProj);
 
@@ -316,10 +319,10 @@ void CBackgroundPainter::OnPostRender()
         pcProj = (aiMe * pcCam) * pcProj;
 
         piSkyBoxEffect->SetMatrix("WorldViewProjection",
-            (const D3DXMATRIX*)&pcProj);
+                (const D3DXMATRIX *)&pcProj);
 
         UINT dwPasses;
-        piSkyBoxEffect->Begin(&dwPasses,0);
+        piSkyBoxEffect->Begin(&dwPasses, 0);
         piSkyBoxEffect->BeginPass(0);
 
         DWORD dw2;
@@ -327,8 +330,8 @@ void CBackgroundPainter::OnPostRender()
         g_piDevice->SetFVF(D3DFVF_XYZ | D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE3(0));
 
         g_piDevice->DrawIndexedPrimitiveUP(
-            D3DPT_TRIANGLELIST,0,8,12,g_cubeIndices,D3DFMT_INDEX16,
-            g_cubeVertices_indexed,sizeof(SkyBoxVertex));
+                D3DPT_TRIANGLELIST, 0, 8, 12, g_cubeIndices, D3DFMT_INDEX16,
+                g_cubeVertices_indexed, sizeof(SkyBoxVertex));
 
         g_piDevice->SetFVF(dw2);
 
@@ -337,135 +340,123 @@ void CBackgroundPainter::OnPostRender()
     }
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::ReleaseNativeResource()
-{
-    if ( piSkyBoxEffect)
-    {
+void CBackgroundPainter::ReleaseNativeResource() {
+    if (piSkyBoxEffect) {
         piSkyBoxEffect->Release();
         piSkyBoxEffect = nullptr;
     }
-    if (pcTexture)
-    {
+    if (pcTexture) {
         pcTexture->Release();
         pcTexture = nullptr;
     }
 }
 //-------------------------------------------------------------------------------
-void CBackgroundPainter::RecreateNativeResource()
-{
-    if (SIMPLE_COLOR == eMode)return;
-    if (TEXTURE_CUBE == eMode)
-    {
+void CBackgroundPainter::RecreateNativeResource() {
+    if (SIMPLE_COLOR == eMode) {
+        return;
+    }
+
+    if (TEXTURE_CUBE == eMode) {
 
         // many skyboxes are 16bit FP format which isn't supported
         // with bilinear filtering on older cards
         D3DFORMAT eFmt = D3DFMT_UNKNOWN;
-        if(FAILED(g_piD3D->CheckDeviceFormat(0,D3DDEVTYPE_HAL,
-            D3DFMT_X8R8G8B8,D3DUSAGE_QUERY_FILTER,D3DRTYPE_CUBETEXTURE,D3DFMT_A16B16G16R16F)))
-        {
+        if (FAILED(g_piD3D->CheckDeviceFormat(0, D3DDEVTYPE_HAL,
+                    D3DFMT_X8R8G8B8, D3DUSAGE_QUERY_FILTER, D3DRTYPE_CUBETEXTURE, D3DFMT_A16B16G16R16F))) {
             eFmt = D3DFMT_A8R8G8B8;
         }
 
         if (FAILED(D3DXCreateCubeTextureFromFileEx(
-            g_piDevice,
-            szPath.c_str(),
-            D3DX_DEFAULT,
-            0,
-            0,
-            eFmt,
-            D3DPOOL_MANAGED,
-            D3DX_DEFAULT,
-            D3DX_DEFAULT,
-            0,
-            nullptr,
-            nullptr,
-            (IDirect3DCubeTexture9**)&pcTexture)))
-        {
-            const char* szEnd = strrchr(szPath.c_str(),'\\');
-            if (!szEnd)szEnd = strrchr(szPath.c_str(),'/');
-            if (!szEnd)szEnd = szPath.c_str()-1;
+                    g_piDevice,
+                    szPath.c_str(),
+                    D3DX_DEFAULT,
+                    0,
+                    0,
+                    eFmt,
+                    D3DPOOL_MANAGED,
+                    D3DX_DEFAULT,
+                    D3DX_DEFAULT,
+                    0,
+                    nullptr,
+                    nullptr,
+                    (IDirect3DCubeTexture9 **)&pcTexture))) {
+            const char *szEnd = strrchr(szPath.c_str(), '\\');
+            if (!szEnd) szEnd = strrchr(szPath.c_str(), '/');
+            if (!szEnd) szEnd = szPath.c_str() - 1;
 
             char szTemp[1024];
-			ai_snprintf(szTemp,1024,"[ERROR] Unable to load background cubemap %s",szEnd+1);
+            ai_snprintf(szTemp, 1024, "[ERROR] Unable to load background cubemap %s", szEnd + 1);
 
             CLogDisplay::Instance().AddEntry(szTemp,
-                D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                    D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
 
             eMode = SIMPLE_COLOR;
             return;
-        }
-        else CLogDisplay::Instance().AddEntry("[OK] The skybox has been imported successfully",
-            D3DCOLOR_ARGB(0xFF,0,0xFF,0));
-    }
-    else
-    {
+        } else
+            CLogDisplay::Instance().AddEntry("[OK] The skybox has been imported successfully",
+                    D3DCOLOR_ARGB(0xFF, 0, 0xFF, 0));
+    } else {
         if (FAILED(D3DXCreateTextureFromFileEx(
-            g_piDevice,
-            szPath.c_str(),
-            D3DX_DEFAULT,
-            D3DX_DEFAULT,
-            0,
-            0,
-            D3DFMT_A8R8G8B8,
-            D3DPOOL_MANAGED,
-            D3DX_DEFAULT,
-            D3DX_DEFAULT,
-            0,
-            nullptr,
-            nullptr,
-            (IDirect3DTexture9**)&pcTexture)))
-        {
-            const char* szEnd = strrchr(szPath.c_str(),'\\');
-            if (!szEnd)szEnd = strrchr(szPath.c_str(),'/');
-            if (!szEnd)szEnd = szPath.c_str()-1;
+                    g_piDevice,
+                    szPath.c_str(),
+                    D3DX_DEFAULT,
+                    D3DX_DEFAULT,
+                    0,
+                    0,
+                    D3DFMT_A8R8G8B8,
+                    D3DPOOL_MANAGED,
+                    D3DX_DEFAULT,
+                    D3DX_DEFAULT,
+                    0,
+                    nullptr,
+                    nullptr,
+                    (IDirect3DTexture9 **)&pcTexture))) {
+            const char *szEnd = strrchr(szPath.c_str(), '\\');
+            if (!szEnd) szEnd = strrchr(szPath.c_str(), '/');
+            if (!szEnd) szEnd = szPath.c_str() - 1;
 
             char szTemp[1024];
-			ai_snprintf(szTemp,1024,"[ERROR] Unable to load background texture %s",szEnd+1);
+            ai_snprintf(szTemp, 1024, "[ERROR] Unable to load background texture %s", szEnd + 1);
 
             CLogDisplay::Instance().AddEntry(szTemp,
-                D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                    D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
 
             eMode = SIMPLE_COLOR;
             return;
-        }
-        else CLogDisplay::Instance().AddEntry("[OK] The background texture has been imported successfully",
-            D3DCOLOR_ARGB(0xFF,0,0xFF,0));
+        } else
+            CLogDisplay::Instance().AddEntry("[OK] The background texture has been imported successfully",
+                    D3DCOLOR_ARGB(0xFF, 0, 0xFF, 0));
     }
-    if (!piSkyBoxEffect)
-    {
-        ID3DXBuffer* piBuffer = nullptr;
-        if(FAILED( D3DXCreateEffect(
-            g_piDevice,
-            g_szSkyboxShader.c_str(),
-            (UINT)g_szSkyboxShader.length(),
-            nullptr,
-            nullptr,
-            AI_SHADER_COMPILE_FLAGS,
-            nullptr,
-            &piSkyBoxEffect,&piBuffer)))
-        {
+    if (!piSkyBoxEffect) {
+        ID3DXBuffer *piBuffer = nullptr;
+        if (FAILED(D3DXCreateEffect(
+                    g_piDevice,
+                    g_szSkyboxShader.c_str(),
+                    (UINT)g_szSkyboxShader.length(),
+                    nullptr,
+                    nullptr,
+                    AI_SHADER_COMPILE_FLAGS,
+                    nullptr,
+                    &piSkyBoxEffect, &piBuffer))) {
             // failed to compile the shader
-            if( piBuffer) {
-                MessageBox(g_hDlg,(LPCSTR)piBuffer->GetBufferPointer(),"HLSL",MB_OK);
+            if (piBuffer) {
+                MessageBox(g_hDlg, (LPCSTR)piBuffer->GetBufferPointer(), "HLSL", MB_OK);
                 piBuffer->Release();
             }
 
             CLogDisplay::Instance().AddEntry("[ERROR] Unable to compile skybox shader",
-                D3DCOLOR_ARGB(0xFF,0xFF,0,0));
+                    D3DCOLOR_ARGB(0xFF, 0xFF, 0, 0));
             eMode = SIMPLE_COLOR;
-            return ;
+            return;
         }
     }
     // commit the correct textures to the shader
-    if (TEXTURE_CUBE == eMode)
-    {
-        piSkyBoxEffect->SetTexture("lw_tex_envmap",pcTexture);
+    if (TEXTURE_CUBE == eMode) {
+        piSkyBoxEffect->SetTexture("lw_tex_envmap", pcTexture);
         piSkyBoxEffect->SetTechnique("RenderSkyBox");
-    }
-    else if (TEXTURE_2D == eMode)
-    {
-        piSkyBoxEffect->SetTexture("TEXTURE_2D",pcTexture);
+    } else if (TEXTURE_2D == eMode) {
+        piSkyBoxEffect->SetTexture("TEXTURE_2D", pcTexture);
         piSkyBoxEffect->SetTechnique("RenderImage2D");
     }
 }
-};
\ No newline at end of file
+}; // namespace AssimpView
diff --git a/tools/assimp_view/CMakeLists.txt b/tools/assimp_view/CMakeLists.txt
index 96b21db40..2785bd882 100644
--- a/tools/assimp_view/CMakeLists.txt
+++ b/tools/assimp_view/CMakeLists.txt
@@ -65,6 +65,10 @@ ADD_EXECUTABLE(  assimp_viewer WIN32
   SceneAnimator.cpp
   Shaders.cpp
   assimp_view.h
+  AnimEvaluator.h
+  SceneAnimator.h
+  MaterialManager.h
+  AssetHelper.h
   assimp_view.cpp
   stdafx.cpp
   assimp_view.rc
@@ -84,7 +88,6 @@ ADD_EXECUTABLE(  assimp_viewer WIN32
 
 SET_PROPERTY(TARGET assimp_viewer PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
 
-
 IF ( MSVC )
   ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
   ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
diff --git a/tools/assimp_view/LogWindow.cpp b/tools/assimp_view/LogWindow.cpp
index 13abd50f3..b430af17c 100644
--- a/tools/assimp_view/LogWindow.cpp
+++ b/tools/assimp_view/LogWindow.cpp
@@ -41,8 +41,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "assimp_view.h"
 #include "richedit.h"
-#include <commoncontrols.h>
 #include <commdlg.h>
+#include <commoncontrols.h>
 
 namespace AssimpView {
 
@@ -51,74 +51,68 @@ CLogWindow CLogWindow::s_cInstance;
 extern HKEY g_hRegistry;
 
 // header for the RTF log file
-static const char* AI_VIEW_RTF_LOG_HEADER =
-    "{\\rtf1"
+static const char *AI_VIEW_RTF_LOG_HEADER =
+        "{\\rtf1"
         "\\ansi"
         "\\deff0"
         "{"
-            "\\fonttbl{\\f0 Courier New;}"
+        "\\fonttbl{\\f0 Courier New;}"
         "}"
-    "{\\colortbl;"
-        "\\red255\\green0\\blue0;"    // red for errors
-        "\\red255\\green120\\blue0;"  // orange for warnings
-        "\\red0\\green150\\blue0;"    // green for infos
-        "\\red0\\green0\\blue180;"    // blue for debug messages
-        "\\red0\\green0\\blue0;"      // black for everything else
-    "}}";
+        "{\\colortbl;"
+        "\\red255\\green0\\blue0;" // red for errors
+        "\\red255\\green120\\blue0;" // orange for warnings
+        "\\red0\\green150\\blue0;" // green for infos
+        "\\red0\\green0\\blue180;" // blue for debug messages
+        "\\red0\\green0\\blue0;" // black for everything else
+        "}}";
 
 //-------------------------------------------------------------------------------
 // Message procedure for the log window
 //-------------------------------------------------------------------------------
-INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg,
-    WPARAM /*wParam*/,LPARAM lParam)
-    {
+INT_PTR CALLBACK LogDialogProc(HWND hwndDlg, UINT uMsg, WPARAM /*wParam*/, LPARAM lParam) {
     (void)lParam;
-    switch (uMsg)
-        {
+    switch (uMsg) {
         case WM_INITDIALOG:
-            {
-
             return TRUE;
-            }
 
-        case WM_SIZE:
-            {
+        case WM_SIZE: {
             int x = LOWORD(lParam);
             int y = HIWORD(lParam);
 
-            SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),nullptr,0,0,
-                x-10,y-12,SWP_NOMOVE|SWP_NOZORDER);
+            SetWindowPos(GetDlgItem(hwndDlg, IDC_EDIT1), nullptr, 0, 0,
+                    x - 10, y - 12, SWP_NOMOVE | SWP_NOZORDER);
 
             return TRUE;
-            }
+        }
         case WM_CLOSE:
-            EndDialog(hwndDlg,0);
+            EndDialog(hwndDlg, 0);
 
             CLogWindow::Instance().bIsVisible = false;
             return TRUE;
-        };
+    };
     return FALSE;
-    }
+}
 
 //-------------------------------------------------------------------------------
-void CLogWindow::Init () {
-    this->hwnd = ::CreateDialog(g_hInstance,MAKEINTRESOURCE(IDD_LOGVIEW),
-        nullptr,&LogDialogProc);
+void CLogWindow::Init() {
+    this->hwnd = ::CreateDialog(g_hInstance, MAKEINTRESOURCE(IDD_LOGVIEW),
+            nullptr, &LogDialogProc);
 
     if (!this->hwnd) {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to create logger window",
-            D3DCOLOR_ARGB(0xFF,0,0xFF,0));
+                D3DCOLOR_ARGB(0xFF, 0, 0xFF, 0));
     }
 
     // setup the log text
-    this->szText = AI_VIEW_RTF_LOG_HEADER;;
+    this->szText = AI_VIEW_RTF_LOG_HEADER;
+    ;
     this->szPlainText = "";
 }
 
 //-------------------------------------------------------------------------------
 void CLogWindow::Show() {
     if (this->hwnd) {
-        ShowWindow(this->hwnd,SW_SHOW);
+        ShowWindow(this->hwnd, SW_SHOW);
         this->bIsVisible = true;
 
         // contents aren't updated while the logger isn't displayed
@@ -127,13 +121,14 @@ void CLogWindow::Show() {
 }
 
 //-------------------------------------------------------------------------------
-void CMyLogStream::write(const char* message) {
+void CMyLogStream::write(const char *message) {
     CLogWindow::Instance().WriteLine(message);
 }
 
 //-------------------------------------------------------------------------------
 void CLogWindow::Clear() {
-    this->szText = AI_VIEW_RTF_LOG_HEADER;;
+    this->szText = AI_VIEW_RTF_LOG_HEADER;
+    ;
     this->szPlainText = "";
 
     this->Update();
@@ -146,8 +141,8 @@ void CLogWindow::Update() {
         sInfo.flags = ST_DEFAULT;
         sInfo.codepage = CP_ACP;
 
-        SendDlgItemMessage(this->hwnd,IDC_EDIT1,
-            EM_SETTEXTEX,(WPARAM)&sInfo,( LPARAM)this->szText.c_str());
+        SendDlgItemMessage(this->hwnd, IDC_EDIT1,
+                EM_SETTEXTEX, (WPARAM)&sInfo, (LPARAM)this->szText.c_str());
     }
 }
 
@@ -156,50 +151,49 @@ void CLogWindow::Save() {
     char szFileName[MAX_PATH];
 
     DWORD dwTemp = MAX_PATH;
-    if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LogDestination",nullptr,nullptr,(BYTE*)szFileName,&dwTemp)) {
+    if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "LogDestination", nullptr, nullptr, (BYTE *)szFileName, &dwTemp)) {
         // Key was not found. Use C:
-        strcpy(szFileName,"");
+        strcpy(szFileName, "");
     } else {
         // need to remove the file name
-        char* sz = strrchr(szFileName,'\\');
+        char *sz = strrchr(szFileName, '\\');
         if (!sz)
-            sz = strrchr(szFileName,'/');
+            sz = strrchr(szFileName, '/');
         if (sz)
             *sz = 0;
     }
     OPENFILENAME sFilename1 = {
         sizeof(OPENFILENAME),
-        g_hDlg,GetModuleHandle(nullptr),
+        g_hDlg, GetModuleHandle(nullptr),
         "Log files\0*.txt", nullptr, 0, 1,
         szFileName, MAX_PATH, nullptr, 0, nullptr,
         "Save log to file",
         OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR,
         0, 1, ".txt", 0, nullptr, nullptr
     };
-    if(GetSaveFileName(&sFilename1) == 0) return;
+    if (GetSaveFileName(&sFilename1) == 0) return;
 
     // Now store the file in the registry
-    RegSetValueExA(g_hRegistry,"LogDestination",0,REG_SZ,(const BYTE*)szFileName,MAX_PATH);
+    RegSetValueExA(g_hRegistry, "LogDestination", 0, REG_SZ, (const BYTE *)szFileName, MAX_PATH);
 
-    FILE* pFile = fopen(szFileName,"wt");
-    fprintf(pFile,this->szPlainText.c_str());
+    FILE *pFile = fopen(szFileName, "wt");
+    fprintf(pFile, this->szPlainText.c_str());
     fclose(pFile);
 
     CLogDisplay::Instance().AddEntry("[INFO] The log file has been saved",
-            D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0));
+            D3DCOLOR_ARGB(0xFF, 0xFF, 0xFF, 0));
 }
 
 //-------------------------------------------------------------------------------
-void CLogWindow::WriteLine(const char* message) {
+void CLogWindow::WriteLine(const char *message) {
     this->szPlainText.append(message);
     this->szPlainText.append("\r\n");
 
     if (0 != this->szText.length()) {
-        this->szText.resize(this->szText.length()-1);
+        this->szText.resize(this->szText.length() - 1);
     }
 
-    switch (message[0])
-    {
+    switch (message[0]) {
     case 'e':
     case 'E':
         this->szText.append("{\\pard \\cf1 \\b \\fs18 ");
@@ -222,11 +216,11 @@ void CLogWindow::WriteLine(const char* message) {
     }
 
     std::string _message = message;
-    for (unsigned int i = 0; i < _message.length();++i) {
+    for (unsigned int i = 0; i < _message.length(); ++i) {
         if ('\\' == _message[i] ||
-            '}'  == _message[i] ||
-            '{'  == _message[i]) {
-            _message.insert(i++,"\\");
+                '}' == _message[i] ||
+                '{' == _message[i]) {
+            _message.insert(i++, "\\");
         }
     }
 
@@ -238,9 +232,9 @@ void CLogWindow::WriteLine(const char* message) {
         sInfo.flags = ST_DEFAULT;
         sInfo.codepage = CP_ACP;
 
-        SendDlgItemMessage(this->hwnd,IDC_EDIT1,
-            EM_SETTEXTEX,(WPARAM)&sInfo,( LPARAM)this->szText.c_str());
+        SendDlgItemMessage(this->hwnd, IDC_EDIT1,
+                EM_SETTEXTEX, (WPARAM)&sInfo, (LPARAM)this->szText.c_str());
     }
 }
 
-} //! AssimpView
+} // namespace AssimpView
diff --git a/tools/assimp_view/Normals.cpp b/tools/assimp_view/Normals.cpp
index 35e89e5b1..d11a49053 100644
--- a/tools/assimp_view/Normals.cpp
+++ b/tools/assimp_view/Normals.cpp
@@ -41,10 +41,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "assimp_view.h"
 
+#include "PostProcessing/CalcTangentsProcess.h"
 #include "PostProcessing/GenFaceNormalsProcess.h"
 #include "PostProcessing/GenVertexNormalsProcess.h"
 #include "PostProcessing/JoinVerticesProcess.h"
-#include "PostProcessing/CalcTangentsProcess.h"
 #include "PostProcessing/MakeVerboseFormat.h"
 
 namespace AssimpView {
@@ -59,14 +59,14 @@ float g_smoothAngle = 80.f;
 //-------------------------------------------------------------------------------
 void AssetHelper::FlipNormalsInt() {
     // invert all normal vectors
-    for (unsigned int i = 0; i < this->pcScene->mNumMeshes;++i) {
-        aiMesh* pcMesh = this->pcScene->mMeshes[i];
+    for (unsigned int i = 0; i < this->pcScene->mNumMeshes; ++i) {
+        aiMesh *pcMesh = this->pcScene->mMeshes[i];
 
         if (!pcMesh->mNormals) {
             continue;
         }
 
-        for (unsigned int a = 0; a < pcMesh->mNumVertices;++a){
+        for (unsigned int a = 0; a < pcMesh->mNumVertices; ++a) {
             pcMesh->mNormals[a] *= -1.0f;
         }
     }
@@ -79,7 +79,7 @@ void AssetHelper::FlipNormals() {
     // recreate native data
     DeleteAssetData(true);
     CreateAssetData();
-    g_bWasFlipped = ! g_bWasFlipped;
+    g_bWasFlipped = !g_bWasFlipped;
 }
 
 //-------------------------------------------------------------------------------
@@ -88,15 +88,15 @@ void AssetHelper::FlipNormals() {
 void AssetHelper::SetNormalSet(unsigned int iSet) {
     // we need to build an unique set of vertices for this ...
     {
-        MakeVerboseFormatProcess* pcProcess = new MakeVerboseFormatProcess();
+        MakeVerboseFormatProcess *pcProcess = new MakeVerboseFormatProcess();
         pcProcess->Execute(pcScene);
         delete pcProcess;
 
-        for (unsigned int i = 0; i < pcScene->mNumMeshes;++i) {
+        for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
             if (!apcMeshes[i]->pvOriginalNormals) {
                 apcMeshes[i]->pvOriginalNormals = new aiVector3D[pcScene->mMeshes[i]->mNumVertices];
-                memcpy( apcMeshes[i]->pvOriginalNormals,pcScene->mMeshes[i]->mNormals,
-                    pcScene->mMeshes[i]->mNumVertices * sizeof(aiVector3D));
+                memcpy(apcMeshes[i]->pvOriginalNormals, pcScene->mMeshes[i]->mNormals,
+                        pcScene->mMeshes[i]->mNumVertices * sizeof(aiVector3D));
             }
             delete[] pcScene->mMeshes[i]->mNormals;
             pcScene->mMeshes[i]->mNormals = nullptr;
@@ -105,18 +105,18 @@ void AssetHelper::SetNormalSet(unsigned int iSet) {
 
     // now we can start to calculate a new set of normals
     if (HARD == iSet) {
-        GenFaceNormalsProcess* pcProcess = new GenFaceNormalsProcess();
+        GenFaceNormalsProcess *pcProcess = new GenFaceNormalsProcess();
         pcProcess->Execute(pcScene);
         FlipNormalsInt();
         delete pcProcess;
     } else if (SMOOTH == iSet) {
-        GenVertexNormalsProcess* pcProcess = new GenVertexNormalsProcess();
+        GenVertexNormalsProcess *pcProcess = new GenVertexNormalsProcess();
         pcProcess->SetMaxSmoothAngle((float)AI_DEG_TO_RAD(g_smoothAngle));
         pcProcess->Execute(pcScene);
         FlipNormalsInt();
         delete pcProcess;
     } else if (ORIGINAL == iSet) {
-        for (unsigned int i = 0; i < pcScene->mNumMeshes;++i) {
+        for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
             if (apcMeshes[i]->pvOriginalNormals) {
                 delete[] pcScene->mMeshes[i]->mNormals;
                 pcScene->mMeshes[i]->mNormals = apcMeshes[i]->pvOriginalNormals;
@@ -126,7 +126,7 @@ void AssetHelper::SetNormalSet(unsigned int iSet) {
     }
 
     // recalculate tangents and bitangents
-    Assimp::BaseProcess* pcProcess = new CalcTangentsProcess();
+    Assimp::BaseProcess *pcProcess = new CalcTangentsProcess();
     pcProcess->Execute(pcScene);
     delete pcProcess;
 
@@ -139,9 +139,9 @@ void AssetHelper::SetNormalSet(unsigned int iSet) {
 
     if (g_bWasFlipped) {
         // invert all normal vectors
-        for (unsigned int i = 0; i < pcScene->mNumMeshes;++i) {
-            aiMesh* pcMesh = pcScene->mMeshes[i];
-            for (unsigned int a = 0; a < pcMesh->mNumVertices;++a) {
+        for (unsigned int i = 0; i < pcScene->mNumMeshes; ++i) {
+            aiMesh *pcMesh = pcScene->mMeshes[i];
+            for (unsigned int a = 0; a < pcMesh->mNumVertices; ++a) {
                 pcMesh->mNormals[a] *= -1.0f;
             }
         }
@@ -152,4 +152,4 @@ void AssetHelper::SetNormalSet(unsigned int iSet) {
     CreateAssetData();
 }
 
-}
+} // namespace AssimpView
diff --git a/tools/assimp_view/SceneAnimator.cpp b/tools/assimp_view/SceneAnimator.cpp
index b6f95329d..ec629406d 100644
--- a/tools/assimp_view/SceneAnimator.cpp
+++ b/tools/assimp_view/SceneAnimator.cpp
@@ -51,23 +51,23 @@ const aiMatrix4x4 IdentityMatrix;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor for a given scene.
-SceneAnimator::SceneAnimator( const aiScene* pScene, size_t pAnimIndex)
-: mScene( pScene )
-, mCurrentAnimIndex( -1 )
-, mAnimEvaluator( nullptr )
-, mRootNode( nullptr ) {
+SceneAnimator::SceneAnimator(const aiScene *pScene, size_t pAnimIndex) :
+        mScene(pScene),
+        mCurrentAnimIndex(-1),
+        mAnimEvaluator(nullptr),
+        mRootNode(nullptr) {
     // build the nodes-for-bones table
-    for (unsigned int i = 0; i < pScene->mNumMeshes;++i) {
-        const aiMesh* mesh = pScene->mMeshes[i];
-        for (unsigned int n = 0; n < mesh->mNumBones;++n) {
-            const aiBone* bone = mesh->mBones[n];
+    for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
+        const aiMesh *mesh = pScene->mMeshes[i];
+        for (unsigned int n = 0; n < mesh->mNumBones; ++n) {
+            const aiBone *bone = mesh->mBones[n];
 
             mBoneNodesByName[bone->mName.data] = pScene->mRootNode->FindNode(bone->mName);
         }
     }
 
     // changing the current animation also creates the node tree for this animation
-    SetAnimIndex( pAnimIndex);
+    SetAnimIndex(pAnimIndex);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -79,51 +79,53 @@ SceneAnimator::~SceneAnimator() {
 
 // ------------------------------------------------------------------------------------------------
 // Sets the animation to use for playback.
-void SceneAnimator::SetAnimIndex( size_t pAnimIndex) {
+void SceneAnimator::SetAnimIndex(size_t pAnimIndex) {
     // no change
-    if (pAnimIndex == static_cast<unsigned int>( mCurrentAnimIndex ) ) {
+    if (pAnimIndex == static_cast<unsigned int>(mCurrentAnimIndex)) {
         return;
     }
 
     // kill data of the previous anim
-    delete mRootNode;  mRootNode = nullptr;
-    delete mAnimEvaluator;  mAnimEvaluator = nullptr;
+    delete mRootNode;
+    mRootNode = nullptr;
+    delete mAnimEvaluator;
+    mAnimEvaluator = nullptr;
     mNodesByName.clear();
 
-    mCurrentAnimIndex = static_cast<int>( pAnimIndex );
+    mCurrentAnimIndex = static_cast<int>(pAnimIndex);
 
     // create the internal node tree. Do this even in case of invalid animation index
     // so that the transformation matrices are properly set up to mimic the current scene
-    mRootNode = CreateNodeTree( mScene->mRootNode, nullptr);
+    mRootNode = CreateNodeTree(mScene->mRootNode, nullptr);
 
     // invalid anim index
-    if (static_cast<unsigned int>( mCurrentAnimIndex )>= mScene->mNumAnimations) {
+    if (static_cast<unsigned int>(mCurrentAnimIndex) >= mScene->mNumAnimations) {
         return;
     }
 
     // create an evaluator for this animation
-    mAnimEvaluator = new AnimEvaluator( mScene->mAnimations[mCurrentAnimIndex]);
+    mAnimEvaluator = new AnimEvaluator(mScene->mAnimations[mCurrentAnimIndex]);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Calculates the node transformations for the scene.
-void SceneAnimator::Calculate( double pTime) {
+void SceneAnimator::Calculate(double pTime) {
     // invalid anim
     if (!mAnimEvaluator) {
         return;
     }
 
     // calculate current local transformations
-    mAnimEvaluator->Evaluate( pTime);
+    mAnimEvaluator->Evaluate(pTime);
 
     // and update all node transformations with the results
-    UpdateTransforms( mRootNode, mAnimEvaluator->GetTransformations());
+    UpdateTransforms(mRootNode, mAnimEvaluator->GetTransformations());
 }
 
 // ------------------------------------------------------------------------------------------------
 // Retrieves the most recent local transformation matrix for the given node.
-const aiMatrix4x4& SceneAnimator::GetLocalTransform( const aiNode* node) const {
-    NodeMap::const_iterator it = mNodesByName.find( node);
+const aiMatrix4x4 &SceneAnimator::GetLocalTransform(const aiNode *node) const {
+    NodeMap::const_iterator it = mNodesByName.find(node);
     if (it == mNodesByName.end()) {
         return IdentityMatrix;
     }
@@ -133,8 +135,8 @@ const aiMatrix4x4& SceneAnimator::GetLocalTransform( const aiNode* node) const {
 
 // ------------------------------------------------------------------------------------------------
 // Retrieves the most recent global transformation matrix for the given node.
-const aiMatrix4x4& SceneAnimator::GetGlobalTransform( const aiNode* node) const {
-    NodeMap::const_iterator it = mNodesByName.find( node);
+const aiMatrix4x4 &SceneAnimator::GetGlobalTransform(const aiNode *node) const {
+    NodeMap::const_iterator it = mNodesByName.find(node);
     if (it == mNodesByName.end()) {
         return IdentityMatrix;
     }
@@ -144,24 +146,24 @@ const aiMatrix4x4& SceneAnimator::GetGlobalTransform( const aiNode* node) const
 
 // ------------------------------------------------------------------------------------------------
 // Calculates the bone matrices for the given mesh.
-const std::vector<aiMatrix4x4>& SceneAnimator::GetBoneMatrices( const aiNode* pNode, size_t pMeshIndex /* = 0 */) {
-    ai_assert( pMeshIndex < pNode->mNumMeshes);
+const std::vector<aiMatrix4x4> &SceneAnimator::GetBoneMatrices(const aiNode *pNode, size_t pMeshIndex /* = 0 */) {
+    ai_assert(pMeshIndex < pNode->mNumMeshes);
     size_t meshIndex = pNode->mMeshes[pMeshIndex];
-    ai_assert( meshIndex < mScene->mNumMeshes);
-    const aiMesh* mesh = mScene->mMeshes[meshIndex];
+    ai_assert(meshIndex < mScene->mNumMeshes);
+    const aiMesh *mesh = mScene->mMeshes[meshIndex];
 
     // resize array and initialize it with identity matrices
-    mTransforms.resize( mesh->mNumBones, aiMatrix4x4());
+    mTransforms.resize(mesh->mNumBones, aiMatrix4x4());
 
     // calculate the mesh's inverse global transform
-    aiMatrix4x4 globalInverseMeshTransform = GetGlobalTransform( pNode);
+    aiMatrix4x4 globalInverseMeshTransform = GetGlobalTransform(pNode);
     globalInverseMeshTransform.Inverse();
 
     // Bone matrices transform from mesh coordinates in bind pose to mesh coordinates in skinned pose
     // Therefore the formula is offsetMatrix * currentGlobalTransform * inverseCurrentMeshTransform
-    for( size_t a = 0; a < mesh->mNumBones; ++a) {
-        const aiBone* bone = mesh->mBones[a];
-        const aiMatrix4x4& currentGlobalTransform = GetGlobalTransform( mBoneNodesByName[ bone->mName.data ]);
+    for (size_t a = 0; a < mesh->mNumBones; ++a) {
+        const aiBone *bone = mesh->mBones[a];
+        const aiMatrix4x4 &currentGlobalTransform = GetGlobalTransform(mBoneNodesByName[bone->mName.data]);
         mTransforms[a] = globalInverseMeshTransform * currentGlobalTransform * bone->mOffsetMatrix;
     }
 
@@ -171,22 +173,22 @@ const std::vector<aiMatrix4x4>& SceneAnimator::GetBoneMatrices( const aiNode* pN
 
 // ------------------------------------------------------------------------------------------------
 // Recursively creates an internal node structure matching the current scene and animation.
-SceneAnimNode* SceneAnimator::CreateNodeTree( aiNode* pNode, SceneAnimNode* pParent) {
+SceneAnimNode *SceneAnimator::CreateNodeTree(aiNode *pNode, SceneAnimNode *pParent) {
     // create a node
-    SceneAnimNode* internalNode = new SceneAnimNode( pNode->mName.data);
+    SceneAnimNode *internalNode = new SceneAnimNode(pNode->mName.data);
     internalNode->mParent = pParent;
     mNodesByName[pNode] = internalNode;
 
     // copy its transformation
     internalNode->mLocalTransform = pNode->mTransformation;
-    CalculateGlobalTransform( internalNode);
+    CalculateGlobalTransform(internalNode);
 
     // find the index of the animation track affecting this node, if any
-    if(static_cast<unsigned int>( mCurrentAnimIndex ) < mScene->mNumAnimations) {
+    if (static_cast<unsigned int>(mCurrentAnimIndex) < mScene->mNumAnimations) {
         internalNode->mChannelIndex = -1;
-        const aiAnimation* currentAnim = mScene->mAnimations[mCurrentAnimIndex];
-        for( unsigned int a = 0; a < currentAnim->mNumChannels; a++) {
-            if( currentAnim->mChannels[a]->mNodeName.data == internalNode->mName) {
+        const aiAnimation *currentAnim = mScene->mAnimations[mCurrentAnimIndex];
+        for (unsigned int a = 0; a < currentAnim->mNumChannels; a++) {
+            if (currentAnim->mChannels[a]->mNodeName.data == internalNode->mName) {
                 internalNode->mChannelIndex = a;
                 break;
             }
@@ -194,9 +196,9 @@ SceneAnimNode* SceneAnimator::CreateNodeTree( aiNode* pNode, SceneAnimNode* pPar
     }
 
     // continue for all child nodes and assign the created internal nodes as our children
-    for( unsigned int a = 0; a < pNode->mNumChildren; ++a ) {
-        SceneAnimNode* childNode = CreateNodeTree( pNode->mChildren[a], internalNode);
-        internalNode->mChildren.push_back( childNode);
+    for (unsigned int a = 0; a < pNode->mNumChildren; ++a) {
+        SceneAnimNode *childNode = CreateNodeTree(pNode->mChildren[a], internalNode);
+        internalNode->mChildren.push_back(childNode);
     }
 
     return internalNode;
@@ -204,29 +206,29 @@ SceneAnimNode* SceneAnimator::CreateNodeTree( aiNode* pNode, SceneAnimNode* pPar
 
 // ------------------------------------------------------------------------------------------------
 // Recursively updates the internal node transformations from the given matrix array
-void SceneAnimator::UpdateTransforms( SceneAnimNode* pNode, const std::vector<aiMatrix4x4>& pTransforms) {
+void SceneAnimator::UpdateTransforms(SceneAnimNode *pNode, const std::vector<aiMatrix4x4> &pTransforms) {
     // update node local transform
-    if( pNode->mChannelIndex != -1) {
-        ai_assert(static_cast<unsigned int>( pNode->mChannelIndex ) < pTransforms.size());
+    if (pNode->mChannelIndex != -1) {
+        ai_assert(static_cast<unsigned int>(pNode->mChannelIndex) < pTransforms.size());
         pNode->mLocalTransform = pTransforms[pNode->mChannelIndex];
     }
 
     // update global transform as well
-    CalculateGlobalTransform( pNode);
+    CalculateGlobalTransform(pNode);
 
     // continue for all children
-    for (std::vector<SceneAnimNode*>::iterator it = pNode->mChildren.begin(); it != pNode->mChildren.end(); ++it) {
+    for (std::vector<SceneAnimNode *>::iterator it = pNode->mChildren.begin(); it != pNode->mChildren.end(); ++it) {
         UpdateTransforms(*it, pTransforms);
     }
 }
 
 // ------------------------------------------------------------------------------------------------
 // Calculates the global transformation matrix for the given internal node
-void SceneAnimator::CalculateGlobalTransform( SceneAnimNode* pInternalNode) {
+void SceneAnimator::CalculateGlobalTransform(SceneAnimNode *pInternalNode) {
     // concatenate all parent transforms to get the global transform for this node
     pInternalNode->mGlobalTransform = pInternalNode->mLocalTransform;
-    SceneAnimNode* node = pInternalNode->mParent;
-    while( node) {
+    SceneAnimNode *node = pInternalNode->mParent;
+    while (node) {
         pInternalNode->mGlobalTransform = node->mLocalTransform * pInternalNode->mGlobalTransform;
         node = node->mParent;
     }
diff --git a/tools/assimp_view/Shaders.cpp b/tools/assimp_view/Shaders.cpp
index f129b7cc6..8adb873a2 100644
--- a/tools/assimp_view/Shaders.cpp
+++ b/tools/assimp_view/Shaders.cpp
@@ -40,39 +40,39 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 #include "assimp_view.h"
 
-namespace AssimpView  {
+namespace AssimpView {
 
 // ------------------------------------------------------------------------------------------------
 std::string g_szNormalsShader = std::string(
 
-    // World * View * Projection matrix\n"
-    // NOTE: Assume that the material uses a WorldViewProjection matrix\n"
-    "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
-    "float4 OUTPUT_COLOR;\n"
-    
-    // Vertex shader input structure
-    "struct VS_INPUT\n"
-    "{\n"
+        // World * View * Projection matrix\n"
+        // NOTE: Assume that the material uses a WorldViewProjection matrix\n"
+        "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
+        "float4 OUTPUT_COLOR;\n"
+
+        // Vertex shader input structure
+        "struct VS_INPUT\n"
+        "{\n"
         "// Position\n"
         "float3 Position : POSITION;\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader output structure for pixel shader usage
-    "struct VS_OUTPUT\n"
-  "{\n"
+        // Vertex shader output structure for pixel shader usage
+        "struct VS_OUTPUT\n"
+        "{\n"
         "float4 Position : POSITION;\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader output structure for FixedFunction usage
-    "struct VS_OUTPUT_FF\n"
-    "{\n"
+        // Vertex shader output structure for FixedFunction usage
+        "struct VS_OUTPUT_FF\n"
+        "{\n"
         "float4 Position : POSITION;\n"
-    "float4 Color : COLOR;\n"
-    "};\n"
+        "float4 Color : COLOR;\n"
+        "};\n"
 
-    // Vertex shader for rendering normals using pixel shader
-    "VS_OUTPUT RenderNormalsVS(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader for rendering normals using pixel shader
+        "VS_OUTPUT RenderNormalsVS(VS_INPUT IN)\n"
+        "{\n"
         "// Initialize the output structure with zero\n"
         "VS_OUTPUT Out = (VS_OUTPUT)0;\n"
 
@@ -80,86 +80,85 @@ std::string g_szNormalsShader = std::string(
         "Out.Position = mul(float4(IN.Position,1.0f),WorldViewProjection);\n"
 
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    // Vertex shader for rendering normals using fixed function pipeline
-    "VS_OUTPUT_FF RenderNormalsVS_FF(VS_INPUT IN)\n"
-  "{\n"
+        // Vertex shader for rendering normals using fixed function pipeline
+        "VS_OUTPUT_FF RenderNormalsVS_FF(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT_FF Out;\n"
         "Out.Position = mul(float4(IN.Position,1.0f),WorldViewProjection);\n"
-    "Out.Color = OUTPUT_COLOR;\n"
+        "Out.Color = OUTPUT_COLOR;\n"
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    // Pixel shader
-    "float4 RenderNormalsPS() : COLOR\n"
-    "{\n"
+        // Pixel shader
+        "float4 RenderNormalsPS() : COLOR\n"
+        "{\n"
         "return OUTPUT_COLOR;\n"
-    "}\n"
+        "}\n"
 
-    // Technique for the normal rendering effect (ps_2_0)
-    "technique RenderNormals\n"
-    "{\n"
+        // Technique for the normal rendering effect (ps_2_0)
+        "technique RenderNormals\n"
+        "{\n"
         "pass p0\n"
         "{\n"
         "CullMode=none;\n"
         "PixelShader = compile ps_2_0 RenderNormalsPS();\n"
         "VertexShader = compile vs_2_0 RenderNormalsVS();\n"
         "}\n"
-    "};\n"
+        "};\n"
 
-    // Technique for the normal rendering effect (fixed function)
-    "technique RenderNormals_FF\n"
-    "{\n"
+        // Technique for the normal rendering effect (fixed function)
+        "technique RenderNormals_FF\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-          "CullMode=none;\n"
-          "VertexShader = compile vs_2_0 RenderNormalsVS_FF();\n"
-      "ColorOp[0] = SelectArg1;\n"
-      "ColorArg0[0] = Diffuse;\n"
-      "AlphaOp[0] = SelectArg1;\n"
-      "AlphaArg0[0] = Diffuse;\n"
+        "CullMode=none;\n"
+        "VertexShader = compile vs_2_0 RenderNormalsVS_FF();\n"
+        "ColorOp[0] = SelectArg1;\n"
+        "ColorArg0[0] = Diffuse;\n"
+        "AlphaOp[0] = SelectArg1;\n"
+        "AlphaArg0[0] = Diffuse;\n"
         "}\n"
-    "};\n"
-    );
+        "};\n");
 
 // ------------------------------------------------------------------------------------------------
 std::string g_szSkyboxShader = std::string(
 
-    // Sampler and texture for the skybox
-    "textureCUBE lw_tex_envmap;\n"
-    "samplerCUBE EnvironmentMapSampler = sampler_state\n"
-    "{\n"
-      "Texture = (lw_tex_envmap);\n"
-      "AddressU = CLAMP;\n"
-      "AddressV = CLAMP;\n"
-      "AddressW = CLAMP;\n"
+        // Sampler and texture for the skybox
+        "textureCUBE lw_tex_envmap;\n"
+        "samplerCUBE EnvironmentMapSampler = sampler_state\n"
+        "{\n"
+        "Texture = (lw_tex_envmap);\n"
+        "AddressU = CLAMP;\n"
+        "AddressV = CLAMP;\n"
+        "AddressW = CLAMP;\n"
 
-      "MAGFILTER = linear;\n"
-      "MINFILTER = linear;\n"
-    "};\n"
+        "MAGFILTER = linear;\n"
+        "MINFILTER = linear;\n"
+        "};\n"
 
-    // World * View * Projection matrix\n"
-    // NOTE: Assume that the material uses a WorldViewProjection matrix\n"
-    "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
-    
-    // Vertex shader input structure
-    "struct VS_INPUT\n"
-    "{\n"
+        // World * View * Projection matrix\n"
+        // NOTE: Assume that the material uses a WorldViewProjection matrix\n"
+        "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
+
+        // Vertex shader input structure
+        "struct VS_INPUT\n"
+        "{\n"
         "float3 Position : POSITION;\n"
         "float3 Texture0 : TEXCOORD0;\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader output structure
-    "struct VS_OUTPUT\n"
-    "{\n"
+        // Vertex shader output structure
+        "struct VS_OUTPUT\n"
+        "{\n"
         "float4 Position : POSITION;\n"
         "float3 Texture0 : TEXCOORD0;\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader
-    "VS_OUTPUT RenderSkyBoxVS(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader
+        "VS_OUTPUT RenderSkyBoxVS(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT Out;\n"
 
         // Multiply with the WorldViewProjection matrix
@@ -167,49 +166,49 @@ std::string g_szSkyboxShader = std::string(
 
         // Set z to w to ensure z becomes 1.0 after the division through w occurs
         "Out.Position.z = Out.Position.w;\n"
-    
+
         // Simply pass through texture coordinates
         "Out.Texture0 = IN.Texture0;\n"
 
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    // Pixel shader
-    "float4 RenderSkyBoxPS(float3 Texture0 : TEXCOORD0) : COLOR\n"
-    "{\n"
+        // Pixel shader
+        "float4 RenderSkyBoxPS(float3 Texture0 : TEXCOORD0) : COLOR\n"
+        "{\n"
         // Lookup the skybox texture
         "return texCUBE(EnvironmentMapSampler,Texture0) ;\n"
-    "}\n"
+        "}\n"
 
-    // Technique for the skybox shader (ps_2_0)
-    "technique RenderSkyBox\n"
-    "{\n"
+        // Technique for the skybox shader (ps_2_0)
+        "technique RenderSkyBox\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-          "ZWriteEnable = FALSE;\n"
-          "FogEnable = FALSE;\n"
-          "CullMode = NONE;\n"
+        "ZWriteEnable = FALSE;\n"
+        "FogEnable = FALSE;\n"
+        "CullMode = NONE;\n"
 
-          "PixelShader = compile ps_2_0 RenderSkyBoxPS();\n"
-          "VertexShader = compile vs_2_0 RenderSkyBoxVS();\n"
+        "PixelShader = compile ps_2_0 RenderSkyBoxPS();\n"
+        "VertexShader = compile vs_2_0 RenderSkyBoxVS();\n"
         "}\n"
-    "};\n"
+        "};\n"
 
-  // -------------- same for static background image -----------------
-    "texture TEXTURE_2D;\n"
-    "sampler TEXTURE_SAMPLER = sampler_state\n"
-    "{\n"
+        // -------------- same for static background image -----------------
+        "texture TEXTURE_2D;\n"
+        "sampler TEXTURE_SAMPLER = sampler_state\n"
+        "{\n"
         "Texture = (TEXTURE_2D);\n"
-    "};\n"
+        "};\n"
 
-    "struct VS_OUTPUT2\n"
-    "{\n"
+        "struct VS_OUTPUT2\n"
+        "{\n"
         "float4 Position : POSITION;\n"
         "float2 TexCoord0 : TEXCOORD0;\n"
-    "};\n"
+        "};\n"
 
-    "VS_OUTPUT2 RenderImageVS(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
-    "{\n"
+        "VS_OUTPUT2 RenderImageVS(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
+        "{\n"
         "VS_OUTPUT2 Out;\n"
 
         "Out.Position.xy = INPosition.xy;\n"
@@ -217,81 +216,80 @@ std::string g_szSkyboxShader = std::string(
         "Out.TexCoord0 = INTexCoord0;\n"
 
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    "float4 RenderImagePS(float2 IN : TEXCOORD0) : COLOR\n"
-    "{\n"
+        "float4 RenderImagePS(float2 IN : TEXCOORD0) : COLOR\n"
+        "{\n"
         "return tex2D(TEXTURE_SAMPLER,IN);\n"
-    "}\n"
+        "}\n"
 
-    // Technique for the background image shader (ps_2_0)
-    "technique RenderImage2D\n"
-    "{\n"
+        // Technique for the background image shader (ps_2_0)
+        "technique RenderImage2D\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "ZWriteEnable = FALSE;\n"
-            "FogEnable = FALSE;\n"
-            "CullMode = NONE;\n"
-    
-            "PixelShader = compile ps_2_0 RenderImagePS();\n"
-            "VertexShader = compile vs_2_0 RenderImageVS();\n"
+        "ZWriteEnable = FALSE;\n"
+        "FogEnable = FALSE;\n"
+        "CullMode = NONE;\n"
+
+        "PixelShader = compile ps_2_0 RenderImagePS();\n"
+        "VertexShader = compile vs_2_0 RenderImageVS();\n"
         "}\n"
-    "};\n"
-    );
+        "};\n");
 
 std::string g_szDefaultShader = std::string(
 
-    // World * View * Projection matrix
-    // NOTE: Assume that the material uses a WorldViewProjection matrix
-    "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
-    "float4x4 World					: WORLD;\n"
-    "float4x3 WorldInverseTranspose	: WORLDINVERSETRANSPOSE;\n"
+        // World * View * Projection matrix
+        // NOTE: Assume that the material uses a WorldViewProjection matrix
+        "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
+        "float4x4 World					: WORLD;\n"
+        "float4x3 WorldInverseTranspose	: WORLDINVERSETRANSPOSE;\n"
 
-    // light colors
-    "float3 afLightColor[5];\n"
-    // light direction
-    "float3 afLightDir[5];\n"
+        // light colors
+        "float3 afLightColor[5];\n"
+        // light direction
+        "float3 afLightDir[5];\n"
 
-    // position of the camera in worldspace\n"
-    "float3 vCameraPos : CAMERAPOSITION;\n"
+        // position of the camera in worldspace\n"
+        "float3 vCameraPos : CAMERAPOSITION;\n"
 
-    // Bone matrices
-//	"#ifdef AV_SKINNING \n"
-    "float4x3 gBoneMatrix[60]; \n"
-//	"#endif // AV_SKINNING \n"
+        // Bone matrices
+        //	"#ifdef AV_SKINNING \n"
+        "float4x3 gBoneMatrix[60]; \n"
+        //	"#endif // AV_SKINNING \n"
 
-    // Vertex shader input structure
-    "struct VS_INPUT\n"
-    "{\n"
+        // Vertex shader input structure
+        "struct VS_INPUT\n"
+        "{\n"
         "float3 Position : POSITION;\n"
         "float3 Normal : NORMAL;\n"
-//		"#ifdef AV_SKINNING \n"
-            "float4 BlendIndices : BLENDINDICES;\n"
-            "float4 BlendWeights : BLENDWEIGHT;\n"
-//		"#endif // AV_SKINNING \n"
-    "};\n"
+        //		"#ifdef AV_SKINNING \n"
+        "float4 BlendIndices : BLENDINDICES;\n"
+        "float4 BlendWeights : BLENDWEIGHT;\n"
+        //		"#endif // AV_SKINNING \n"
+        "};\n"
 
-    // Vertex shader output structure for pixel shader usage
-    "struct VS_OUTPUT\n"
-    "{\n"
+        // Vertex shader output structure for pixel shader usage
+        "struct VS_OUTPUT\n"
+        "{\n"
         "float4 Position : POSITION;\n"
         "float3 ViewDir : TEXCOORD0;\n"
         "float3 Normal : TEXCOORD1;\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader output structure for fixed function
-    "struct VS_OUTPUT_FF\n"
-    "{\n"
+        // Vertex shader output structure for fixed function
+        "struct VS_OUTPUT_FF\n"
+        "{\n"
         "float4 Position : POSITION;\n"
         "float4 Color : COLOR;\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader for pixel shader usage
-    "VS_OUTPUT DefaultVShader(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader for pixel shader usage
+        "VS_OUTPUT DefaultVShader(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT Out;\n"
 
-//		"#ifdef AV_SKINNING \n"
+        //		"#ifdef AV_SKINNING \n"
         "float4 weights = IN.BlendWeights; \n"
         "weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
         "float4 localPos = float4( IN.Position, 1.0f); \n"
@@ -299,9 +297,9 @@ std::string g_szDefaultShader = std::string(
         "objPos += mul( localPos, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
         "objPos += mul( localPos, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
         "objPos += mul( localPos, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
-//		"#else \n"
-//		"float3 objPos = IN.Position; \n"
-//		"#endif // AV_SKINNING \n"
+        //		"#else \n"
+        //		"float3 objPos = IN.Position; \n"
+        //		"#endif // AV_SKINNING \n"
 
         // Multiply with the WorldViewProjection matrix
         "Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
@@ -310,14 +308,14 @@ std::string g_szDefaultShader = std::string(
         "Out.Normal = mul(IN.Normal,WorldInverseTranspose);\n"
 
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    // Vertex shader for fixed function pipeline
-    "VS_OUTPUT_FF DefaultVShader_FF(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader for fixed function pipeline
+        "VS_OUTPUT_FF DefaultVShader_FF(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT_FF Out;\n"
 
-//		"#ifdef AV_SKINNING \n"
+        //		"#ifdef AV_SKINNING \n"
         "float4 weights = IN.BlendWeights; \n"
         "weights.w = 1.0f - dot( weights.xyz, float3( 1, 1, 1)); \n"
         "float4 localPos = float4( IN.Position, 1.0f); \n"
@@ -325,9 +323,9 @@ std::string g_szDefaultShader = std::string(
         "objPos += mul( localPos, gBoneMatrix[IN.BlendIndices.y]) * weights.y; \n"
         "objPos += mul( localPos, gBoneMatrix[IN.BlendIndices.z]) * weights.z; \n"
         "objPos += mul( localPos, gBoneMatrix[IN.BlendIndices.w]) * weights.w; \n"
-//		"#else \n"
-//		"float3 objPos = IN.Position; \n"
-//		"#endif // AV_SKINNING \n"
+        //		"#else \n"
+        //		"float3 objPos = IN.Position; \n"
+        //		"#endif // AV_SKINNING \n"
 
         // Multiply with the WorldViewProjection matrix
         "Out.Position = mul( float4( objPos, 1.0f), WorldViewProjection);\n"
@@ -338,288 +336,285 @@ std::string g_szDefaultShader = std::string(
         "Out.Color = float4( 0.2f, 0.2f, 0.2f, 1.0f); \n"
         "for( int a = 0; a < 2; a++)\n"
         "  Out.Color.rgb += saturate( dot( afLightDir[a], worldNormal)) * afLightColor[a].rgb; \n"
-            "return Out;\n"
-    "}\n"
+        "return Out;\n"
+        "}\n"
 
-    // Pixel shader for one light
-    "float4 DefaultPShaderSpecular_D1(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        // Pixel shader for one light
+        "float4 DefaultPShaderSpecular_D1(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "float3 Normal = normalize(IN.Normal);\n"
         "float3 ViewDir = normalize(IN.ViewDir);\n"
 
         "{\n"
-            "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
-            "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
-            "float fHalfLambert = L1*L1;\n"
-            "OUT.rgb += afLightColor[0] * (fHalfLambert +\n"
-                "saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,ViewDir),9));\n"
+        "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
+        "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
+        "float fHalfLambert = L1*L1;\n"
+        "OUT.rgb += afLightColor[0] * (fHalfLambert +\n"
+        "saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,ViewDir),9));\n"
         "}\n"
         "return OUT;\n"
-    "}\n"
+        "}\n"
 
-    // Pixel shader for two lights
-    "float4 DefaultPShaderSpecular_D2(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        // Pixel shader for two lights
+        "float4 DefaultPShaderSpecular_D2(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "float3 Normal = normalize(IN.Normal);\n"
         "float3 ViewDir = normalize(IN.ViewDir);\n"
 
         "{\n"
-            "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
-            "float3 Reflect = reflect (ViewDir,Normal);\n"
-            "float fHalfLambert = L1*L1;\n"
-            "OUT.rgb += afLightColor[0] * (fHalfLambert +\n"
-            "saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,afLightDir[0]),9));\n"
+        "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
+        "float3 Reflect = reflect (ViewDir,Normal);\n"
+        "float fHalfLambert = L1*L1;\n"
+        "OUT.rgb += afLightColor[0] * (fHalfLambert +\n"
+        "saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,afLightDir[0]),9));\n"
         "}\n"
         "{\n"
-            "float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
-            "float3 Reflect = reflect (ViewDir,Normal);\n"
-            "float fHalfLambert = L1*L1;\n"
-            "OUT.rgb += afLightColor[1] * (fHalfLambert +\n"
-            "saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,afLightDir[1]),9));\n"
+        "float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
+        "float3 Reflect = reflect (ViewDir,Normal);\n"
+        "float fHalfLambert = L1*L1;\n"
+        "OUT.rgb += afLightColor[1] * (fHalfLambert +\n"
+        "saturate(fHalfLambert * 4.0f) * pow(dot(Reflect,afLightDir[1]),9));\n"
         "}\n"
         "return OUT;\n"
-    "}\n"
-    // ----------------------------------------------------------------------------
-    "float4 DefaultPShaderSpecular_PS20_D1(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        "}\n"
+        // ----------------------------------------------------------------------------
+        "float4 DefaultPShaderSpecular_PS20_D1(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "float3 Normal = normalize(IN.Normal);\n"
         "float3 ViewDir = normalize(IN.ViewDir);\n"
 
         "{\n"
-            "float L1 = dot(Normal,afLightDir[0]);\n"
-            "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
-            "OUT.rgb += afLightColor[0] * ((L1) +\n"
-            "pow(dot(Reflect,ViewDir),9));\n"
+        "float L1 = dot(Normal,afLightDir[0]);\n"
+        "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
+        "OUT.rgb += afLightColor[0] * ((L1) +\n"
+        "pow(dot(Reflect,ViewDir),9));\n"
         "}\n"
 
         "return OUT;\n"
-    "}\n"
-    // ----------------------------------------------------------------------------
-    "float4 DefaultPShaderSpecular_PS20_D2(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        "}\n"
+        // ----------------------------------------------------------------------------
+        "float4 DefaultPShaderSpecular_PS20_D2(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "float3 Normal = normalize(IN.Normal);\n"
         "float3 ViewDir = normalize(IN.ViewDir);\n"
 
         "{\n"
-            "float L1 = dot(Normal,afLightDir[0]);\n"
-            "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
-            "OUT.rgb += afLightColor[0] * ((L1) +\n"
-            "pow(dot(Reflect,ViewDir),9));\n"
+        "float L1 = dot(Normal,afLightDir[0]);\n"
+        "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
+        "OUT.rgb += afLightColor[0] * ((L1) +\n"
+        "pow(dot(Reflect,ViewDir),9));\n"
         "}\n"
         "{\n"
-            "float L1 = dot(Normal,afLightDir[1]);\n"
-            "float3 Reflect = reflect (Normal,afLightDir[1]);\n"
-            "OUT.rgb += afLightColor[1] * ((L1) +\n"
-            "pow(dot(Reflect,ViewDir),9));\n"
+        "float L1 = dot(Normal,afLightDir[1]);\n"
+        "float3 Reflect = reflect (Normal,afLightDir[1]);\n"
+        "OUT.rgb += afLightColor[1] * ((L1) +\n"
+        "pow(dot(Reflect,ViewDir),9));\n"
         "}\n"
         "return OUT;\n"
-    "}\n"
+        "}\n"
 
-
-    // Technique for the default effect
-    "technique DefaultFXSpecular_D1\n"
-    "{\n"
+        // Technique for the default effect
+        "technique DefaultFXSpecular_D1\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "CullMode=none;\n"
-            "PixelShader = compile ps_3_0 DefaultPShaderSpecular_D1();\n"
-            "VertexShader = compile vs_3_0 DefaultVShader();\n"
+        "CullMode=none;\n"
+        "PixelShader = compile ps_3_0 DefaultPShaderSpecular_D1();\n"
+        "VertexShader = compile vs_3_0 DefaultVShader();\n"
         "}\n"
-    "};\n"
-    "technique DefaultFXSpecular_D2\n"
-    "{\n"
+        "};\n"
+        "technique DefaultFXSpecular_D2\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "CullMode=none;\n"
-            "PixelShader = compile ps_3_0 DefaultPShaderSpecular_D2();\n"
-            "VertexShader = compile vs_3_0 DefaultVShader();\n"
+        "CullMode=none;\n"
+        "PixelShader = compile ps_3_0 DefaultPShaderSpecular_D2();\n"
+        "VertexShader = compile vs_3_0 DefaultVShader();\n"
         "}\n"
-    "};\n"
+        "};\n"
 
-    // Technique for the default effect (ps_2_0)
-    "technique DefaultFXSpecular_PS20_D1\n"
-    "{\n"
-        "pass p0\n"
-    "{\n"
-          "CullMode=none;\n"
-          "PixelShader = compile ps_2_0 DefaultPShaderSpecular_PS20_D1();\n"
-          "VertexShader = compile vs_2_0 DefaultVShader();\n"
-        "}\n"
-    "};\n"
-    "technique DefaultFXSpecular_PS20_D2\n"
-    "{\n"
+        // Technique for the default effect (ps_2_0)
+        "technique DefaultFXSpecular_PS20_D1\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-          "CullMode=none;\n"
-          "PixelShader = compile ps_2_0 DefaultPShaderSpecular_PS20_D2();\n"
-          "VertexShader = compile vs_2_0 DefaultVShader();\n"
+        "CullMode=none;\n"
+        "PixelShader = compile ps_2_0 DefaultPShaderSpecular_PS20_D1();\n"
+        "VertexShader = compile vs_2_0 DefaultVShader();\n"
         "}\n"
-    "};\n"
-
-    // Technique for the default effect using the fixed function pixel pipeline
-    "technique DefaultFXSpecular_FF\n"
-    "{\n"
+        "};\n"
+        "technique DefaultFXSpecular_PS20_D2\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "CullMode=none;\n"
-            "VertexShader = compile vs_2_0 DefaultVShader_FF();\n"
-            "ColorOp[0] = SelectArg1;\n"
-            "ColorArg0[0] = Diffuse;\n"
-            "AlphaOp[0] = SelectArg1;\n"
-            "AlphaArg0[0] = Diffuse;\n"
+        "CullMode=none;\n"
+        "PixelShader = compile ps_2_0 DefaultPShaderSpecular_PS20_D2();\n"
+        "VertexShader = compile vs_2_0 DefaultVShader();\n"
         "}\n"
-    "};\n"
-  );
+        "};\n"
 
+        // Technique for the default effect using the fixed function pixel pipeline
+        "technique DefaultFXSpecular_FF\n"
+        "{\n"
+        "pass p0\n"
+        "{\n"
+        "CullMode=none;\n"
+        "VertexShader = compile vs_2_0 DefaultVShader_FF();\n"
+        "ColorOp[0] = SelectArg1;\n"
+        "ColorArg0[0] = Diffuse;\n"
+        "AlphaOp[0] = SelectArg1;\n"
+        "AlphaArg0[0] = Diffuse;\n"
+        "}\n"
+        "};\n");
 
 std::string g_szMaterialShader = std::string(
 
-    // World * View * Projection matrix
-  // NOTE: Assume that the material uses a WorldViewProjection matrix
-    "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
-    "float4x4 World					: WORLD;\n"
-    "float4x3 WorldInverseTranspose	: WORLDINVERSETRANSPOSE;\n"
+        // World * View * Projection matrix
+        // NOTE: Assume that the material uses a WorldViewProjection matrix
+        "float4x4 WorldViewProjection	: WORLDVIEWPROJECTION;\n"
+        "float4x4 World					: WORLD;\n"
+        "float4x3 WorldInverseTranspose	: WORLDINVERSETRANSPOSE;\n"
 
-    "#ifndef AV_DISABLESSS\n"
-    "float4x3 ViewProj;\n"
-    "float4x3 InvViewProj;\n"
-    "#endif\n"
+        "#ifndef AV_DISABLESSS\n"
+        "float4x3 ViewProj;\n"
+        "float4x3 InvViewProj;\n"
+        "#endif\n"
 
-    "float4 DIFFUSE_COLOR;\n"
-    "float4 SPECULAR_COLOR;\n"
-    "float4 AMBIENT_COLOR;\n"
-    "float4 EMISSIVE_COLOR;\n"
+        "float4 DIFFUSE_COLOR;\n"
+        "float4 SPECULAR_COLOR;\n"
+        "float4 AMBIENT_COLOR;\n"
+        "float4 EMISSIVE_COLOR;\n"
 
-    "#ifdef AV_SPECULAR_COMPONENT\n"
-    "float SPECULARITY;\n"
-    "float SPECULAR_STRENGTH;\n"
-    "#endif\n"
-    "#ifdef AV_OPACITY\n"
-    "float TRANSPARENCY;\n"
-    "#endif\n"
+        "#ifdef AV_SPECULAR_COMPONENT\n"
+        "float SPECULARITY;\n"
+        "float SPECULAR_STRENGTH;\n"
+        "#endif\n"
+        "#ifdef AV_OPACITY\n"
+        "float TRANSPARENCY;\n"
+        "#endif\n"
 
-    // light colors (diffuse and specular)
-    "float4 afLightColor[5];\n"
-    "float4 afLightColorAmbient[5];\n"
+        // light colors (diffuse and specular)
+        "float4 afLightColor[5];\n"
+        "float4 afLightColorAmbient[5];\n"
 
-    // light direction
-    "float3 afLightDir[5];\n"
+        // light direction
+        "float3 afLightDir[5];\n"
 
-    // position of the camera in worldspace
-    "float3 vCameraPos : CAMERAPOSITION;\n"
+        // position of the camera in worldspace
+        "float3 vCameraPos : CAMERAPOSITION;\n"
 
-    // Bone matrices
-    "#ifdef AV_SKINNING \n"
-    "float4x3 gBoneMatrix[60]; \n"
-    "#endif // AV_SKINNING \n"
+        // Bone matrices
+        "#ifdef AV_SKINNING \n"
+        "float4x3 gBoneMatrix[60]; \n"
+        "#endif // AV_SKINNING \n"
 
-    "#ifdef AV_DIFFUSE_TEXTURE\n"
+        "#ifdef AV_DIFFUSE_TEXTURE\n"
         "texture DIFFUSE_TEXTURE;\n"
         "sampler DIFFUSE_SAMPLER\n"
         "{\n"
-          "Texture = <DIFFUSE_TEXTURE>;\n"
-          "#ifdef AV_WRAPU\n"
-          "AddressU = WRAP;\n"
-          "#endif\n"
-          "#ifdef AV_MIRRORU\n"
-          "AddressU = MIRROR;\n"
-          "#endif\n"
-          "#ifdef AV_CLAMPU\n"
-          "AddressU = CLAMP;\n"
-          "#endif\n"
-          "#ifdef AV_WRAPV\n"
-          "AddressV = WRAP;\n"
-          "#endif\n"
-          "#ifdef AV_MIRRORV\n"
-          "AddressV = MIRROR;\n"
-          "#endif\n"
-          "#ifdef AV_CLAMPV\n"
-          "AddressV = CLAMP;\n"
-          "#endif\n"
+        "Texture = <DIFFUSE_TEXTURE>;\n"
+        "#ifdef AV_WRAPU\n"
+        "AddressU = WRAP;\n"
+        "#endif\n"
+        "#ifdef AV_MIRRORU\n"
+        "AddressU = MIRROR;\n"
+        "#endif\n"
+        "#ifdef AV_CLAMPU\n"
+        "AddressU = CLAMP;\n"
+        "#endif\n"
+        "#ifdef AV_WRAPV\n"
+        "AddressV = WRAP;\n"
+        "#endif\n"
+        "#ifdef AV_MIRRORV\n"
+        "AddressV = MIRROR;\n"
+        "#endif\n"
+        "#ifdef AV_CLAMPV\n"
+        "AddressV = CLAMP;\n"
+        "#endif\n"
         "};\n"
-    "#endif // AV_DIFFUSE_TEXTUR\n"
+        "#endif // AV_DIFFUSE_TEXTUR\n"
 
-    "#ifdef AV_DIFFUSE_TEXTURE2\n"
+        "#ifdef AV_DIFFUSE_TEXTURE2\n"
         "texture DIFFUSE_TEXTURE2;\n"
         "sampler DIFFUSE_SAMPLER2\n"
         "{\n"
-          "Texture = <DIFFUSE_TEXTURE2>;\n"
+        "Texture = <DIFFUSE_TEXTURE2>;\n"
         "};\n"
-    "#endif // AV_DIFFUSE_TEXTUR2\n"
+        "#endif // AV_DIFFUSE_TEXTUR2\n"
 
-    "#ifdef AV_SPECULAR_TEXTURE\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
         "texture SPECULAR_TEXTURE;\n"
         "sampler SPECULAR_SAMPLER\n"
         "{\n"
-          "Texture = <SPECULAR_TEXTURE>;\n"
+        "Texture = <SPECULAR_TEXTURE>;\n"
         "};\n"
-    "#endif // AV_SPECULAR_TEXTUR\n"
+        "#endif // AV_SPECULAR_TEXTUR\n"
 
-    "#ifdef AV_AMBIENT_TEXTURE\n"
+        "#ifdef AV_AMBIENT_TEXTURE\n"
         "texture AMBIENT_TEXTURE;\n"
         "sampler AMBIENT_SAMPLER\n"
         "{\n"
-          "Texture = <AMBIENT_TEXTURE>;\n"
+        "Texture = <AMBIENT_TEXTURE>;\n"
         "};\n"
-    "#endif // AV_AMBIENT_TEXTUR\n"
+        "#endif // AV_AMBIENT_TEXTUR\n"
 
-    "#ifdef AV_LIGHTMAP_TEXTURE\n"
+        "#ifdef AV_LIGHTMAP_TEXTURE\n"
         "texture LIGHTMAP_TEXTURE;\n"
         "sampler LIGHTMAP_SAMPLER\n"
         "{\n"
-          "Texture = <LIGHTMAP_TEXTURE>;\n"
+        "Texture = <LIGHTMAP_TEXTURE>;\n"
         "};\n"
-    "#endif // AV_LIGHTMAP_TEXTURE\n"
+        "#endif // AV_LIGHTMAP_TEXTURE\n"
 
-    "#ifdef AV_OPACITY_TEXTURE\n"
+        "#ifdef AV_OPACITY_TEXTURE\n"
         "texture OPACITY_TEXTURE;\n"
         "sampler OPACITY_SAMPLER\n"
         "{\n"
-          "Texture = <OPACITY_TEXTURE>;\n"
+        "Texture = <OPACITY_TEXTURE>;\n"
         "};\n"
-    "#endif // AV_OPACITY_TEXTURE\n"
+        "#endif // AV_OPACITY_TEXTURE\n"
 
-    "#ifdef AV_EMISSIVE_TEXTURE\n"
+        "#ifdef AV_EMISSIVE_TEXTURE\n"
         "texture EMISSIVE_TEXTURE;\n"
         "sampler EMISSIVE_SAMPLER\n"
         "{\n"
-          "Texture = <EMISSIVE_TEXTURE>;\n"
+        "Texture = <EMISSIVE_TEXTURE>;\n"
         "};\n"
-    "#endif // AV_EMISSIVE_TEXTUR\n"
+        "#endif // AV_EMISSIVE_TEXTUR\n"
 
-    "#ifdef AV_NORMAL_TEXTURE\n"
+        "#ifdef AV_NORMAL_TEXTURE\n"
         "texture NORMAL_TEXTURE;\n"
         "sampler NORMAL_SAMPLER\n"
         "{\n"
-          "Texture = <NORMAL_TEXTURE>;\n"
+        "Texture = <NORMAL_TEXTURE>;\n"
         "};\n"
-    "#endif // AV_NORMAL_TEXTURE\n"
+        "#endif // AV_NORMAL_TEXTURE\n"
 
-    "#ifdef AV_SKYBOX_LOOKUP\n"
+        "#ifdef AV_SKYBOX_LOOKUP\n"
         "textureCUBE lw_tex_envmap;\n"
         "samplerCUBE EnvironmentMapSampler = sampler_state\n"
         "{\n"
-          "Texture = (lw_tex_envmap);\n"
-          "AddressU = CLAMP;\n"
-          "AddressV = CLAMP;\n"
-          "AddressW = CLAMP;\n"
+        "Texture = (lw_tex_envmap);\n"
+        "AddressU = CLAMP;\n"
+        "AddressV = CLAMP;\n"
+        "AddressW = CLAMP;\n"
 
-          "MAGFILTER = linear;\n"
-          "MINFILTER = linear;\n"
+        "MAGFILTER = linear;\n"
+        "MINFILTER = linear;\n"
         "};\n"
-    "#endif // AV_SKYBOX_LOOKUP\n"
+        "#endif // AV_SKYBOX_LOOKUP\n"
 
-    // Vertex shader input structure
-    "struct VS_INPUT\n"
-    "{\n"
+        // Vertex shader input structure
+        "struct VS_INPUT\n"
+        "{\n"
         "float3 Position : POSITION;\n"
         "float3 Normal : NORMAL;\n"
         "float4 Color : COLOR0;\n"
@@ -629,15 +624,15 @@ std::string g_szMaterialShader = std::string(
         "#ifdef AV_TWO_UV \n"
         "float2 TexCoord1 : TEXCOORD1;\n"
         "#endif \n"
-          "#ifdef AV_SKINNING \n"
-            "float4 BlendIndices : BLENDINDICES;\n"
-            "float4 BlendWeights : BLENDWEIGHT;\n"
-         "#endif // AV_SKINNING \n"
-    "};\n"
+        "#ifdef AV_SKINNING \n"
+        "float4 BlendIndices : BLENDINDICES;\n"
+        "float4 BlendWeights : BLENDWEIGHT;\n"
+        "#endif // AV_SKINNING \n"
+        "};\n"
 
-    // Vertex shader output structure for pixel shader usage
-    "struct VS_OUTPUT\n"
-    "{\n"
+        // Vertex shader output structure for pixel shader usage
+        "struct VS_OUTPUT\n"
+        "{\n"
         "float4 Position : POSITION;\n"
         "float3 ViewDir : TEXCOORD0;\n"
 
@@ -656,25 +651,23 @@ std::string g_szMaterialShader = std::string(
         "float3 Light0 : TEXCOORD3;\n"
         "float3 Light1 : TEXCOORD4;\n"
         "#endif\n"
-    "};\n"
+        "};\n"
 
-    // Vertex shader output structure for fixed function pixel pipeline
-    "struct VS_OUTPUT_FF\n"
-    "{\n"
+        // Vertex shader output structure for fixed function pixel pipeline
+        "struct VS_OUTPUT_FF\n"
+        "{\n"
         "float4 Position : POSITION;\n"
         "float4 DiffuseColor : COLOR0;\n"
         "float4 SpecularColor : COLOR1;\n"
         "float2 TexCoord0 : TEXCOORD0;\n"
-    "};\n"
+        "};\n"
 
+        // Selective SuperSampling in screenspace for reflection lookups
+        "#define GetSSSCubeMap(_refl) (texCUBElod(EnvironmentMapSampler,float4(_refl,0.0f)).rgb) \n"
 
-    // Selective SuperSampling in screenspace for reflection lookups
-    "#define GetSSSCubeMap(_refl) (texCUBElod(EnvironmentMapSampler,float4(_refl,0.0f)).rgb) \n"
-
-
-    // Vertex shader for pixel shader usage and one light
-    "VS_OUTPUT MaterialVShader_D1(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader for pixel shader usage and one light
+        "VS_OUTPUT MaterialVShader_D1(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT Out = (VS_OUTPUT)0;\n"
 
         "#ifdef AV_SKINNING \n"
@@ -702,7 +695,7 @@ std::string g_szMaterialShader = std::string(
         "Out.ViewDir = vCameraPos - WorldPos;\n"
         "Out.Normal = mul(IN.Normal,WorldInverseTranspose);\n"
         "#endif\n"
-        
+
         "#ifdef AV_NORMAL_TEXTURE\n"
         "float3x3 TBNMatrix = float3x3(IN.Tangent, IN.Bitangent, IN.Normal);\n"
         "float3x3 WTTS      = mul(TBNMatrix, (float3x3)WorldInverseTranspose);\n"
@@ -710,11 +703,11 @@ std::string g_szMaterialShader = std::string(
         "Out.ViewDir = normalize(mul(WTTS, (vCameraPos - WorldPos)));\n"
         "#endif\n"
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    // Vertex shader for pixel shader usage and two lights
-    "VS_OUTPUT MaterialVShader_D2(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader for pixel shader usage and two lights
+        "VS_OUTPUT MaterialVShader_D2(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT Out = (VS_OUTPUT)0;\n"
 
         "#ifdef AV_SKINNING \n"
@@ -751,11 +744,11 @@ std::string g_szMaterialShader = std::string(
         "Out.ViewDir = normalize(mul(WTTS, (vCameraPos - WorldPos)));\n"
         "#endif\n"
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-    // Vertex shader for zero to five lights using the fixed function pixel pipeline
-    "VS_OUTPUT_FF MaterialVShader_FF(VS_INPUT IN)\n"
-    "{\n"
+        // Vertex shader for zero to five lights using the fixed function pixel pipeline
+        "VS_OUTPUT_FF MaterialVShader_FF(VS_INPUT IN)\n"
+        "{\n"
         "VS_OUTPUT_FF Out = (VS_OUTPUT_FF)0;\n"
 
         "#ifdef AV_SKINNING \n"
@@ -798,12 +791,11 @@ std::string g_szMaterialShader = std::string(
         "Out.SpecularColor = specularColor * SPECULAR_COLOR + EMISSIVE_COLOR; \n"
 
         "return Out;\n"
-    "}\n"
+        "}\n"
 
-
-    // Pixel shader - one light
-    "float4 MaterialPShaderSpecular_D1(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        // Pixel shader - one light
+        "float4 MaterialPShaderSpecular_D1(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "#ifdef AV_NORMAL_TEXTURE\n"
@@ -814,56 +806,55 @@ std::string g_szMaterialShader = std::string(
         "#endif \n"
         "float3 ViewDir = normalize(IN.ViewDir);\n"
         "#ifdef AV_SPECULAR_COMPONENT\n"
-            "float3 Reflect = normalize(reflect (-ViewDir,Normal));\n"
+        "float3 Reflect = normalize(reflect (-ViewDir,Normal));\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
 
         "{\n"
         "#ifdef AV_NORMAL_TEXTURE\n"
-            "float L1 =  dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
-            "#define AV_LIGHT_0 IN_Light0\n"
-            // would need to convert the reflection vector into world space ....
-            // simply let it ...
+        "float L1 =  dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
+        "#define AV_LIGHT_0 IN_Light0\n"
+        // would need to convert the reflection vector into world space ....
+        // simply let it ...
         "#else\n"
-            "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
-            "#define AV_LIGHT_0 afLightDir[0]\n"
+        "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
+        "#define AV_LIGHT_0 afLightDir[0]\n"
         "#endif\n"
         "#ifdef AV_DIFFUSE_TEXTURE2\n"
-            "float fHalfLambert = 1.f;\n"
+        "float fHalfLambert = 1.f;\n"
         "#else\n"
-            "float fHalfLambert = L1*L1;\n"
+        "float fHalfLambert = L1*L1;\n"
         "#endif \n"
         "#ifdef AV_DIFFUSE_TEXTURE\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert * IN.Color.rgb +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert * IN.Color.rgb +\n"
         "#else\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * fHalfLambert * IN.Color.rgb +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * fHalfLambert * IN.Color.rgb +\n"
         "#endif // !AV_DIFFUSE_TEXTURE\n"
 
-        
         "#ifdef AV_SPECULAR_COMPONENT\n"
-            "#ifndef AV_SKYBOX_LOOKUP\n"
-                "#ifdef AV_SPECULAR_TEXTURE\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#else\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#endif // !AV_SPECULAR_TEXTURE\n"
-            "#else\n"
-                "#ifdef AV_SPECULAR_TEXTURE\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#else\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#endif // !AV_SPECULAR_TEXTURE\n"
-            "#endif // !AV_SKYBOX_LOOKUP\n"
+        "#ifndef AV_SKYBOX_LOOKUP\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#else\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#endif // !AV_SPECULAR_TEXTURE\n"
+        "#else\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#else\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#endif // !AV_SPECULAR_TEXTURE\n"
+        "#endif // !AV_SKYBOX_LOOKUP\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
 
         "#ifdef AV_AMBIENT_TEXTURE\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
         "#else\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb + \n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb + \n"
         "#endif // !AV_AMBIENT_TEXTURE\n"
-            "#ifdef AV_EMISSIVE_TEXTURE\n"
-            "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
+        "#ifdef AV_EMISSIVE_TEXTURE\n"
+        "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
         "#else \n"
-            "EMISSIVE_COLOR.rgb;\n"
+        "EMISSIVE_COLOR.rgb;\n"
         "#endif // !AV_EMISSIVE_TEXTURE\n"
         "}\n"
         "#ifdef AV_OPACITY\n"
@@ -878,11 +869,11 @@ std::string g_szMaterialShader = std::string(
         "return OUT;\n"
 
         "#undef AV_LIGHT_0\n"
-    "}\n"
+        "}\n"
 
-    // Pixel shader - two lights
-    "float4 MaterialPShaderSpecular_D2(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        // Pixel shader - two lights
+        "float4 MaterialPShaderSpecular_D2(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "#ifdef AV_NORMAL_TEXTURE\n"
@@ -894,91 +885,91 @@ std::string g_szMaterialShader = std::string(
         "#endif \n"
         "float3 ViewDir = normalize(IN.ViewDir);\n"
         "#ifdef AV_SPECULAR_COMPONENT\n"
-            "float3 Reflect = -normalize(reflect (ViewDir,Normal));\n"
+        "float3 Reflect = -normalize(reflect (ViewDir,Normal));\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
 
         "{\n"
-        
+
         "#ifdef AV_NORMAL_TEXTURE\n"
-            "float L1 = dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
-            "#define AV_LIGHT_0 IN_Light0\n"
+        "float L1 = dot(Normal,IN_Light0) * 0.5f + 0.5f;\n"
+        "#define AV_LIGHT_0 IN_Light0\n"
         "#else\n"
-            "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
-            "#define AV_LIGHT_0 afLightDir[0]\n"
+        "float L1 = dot(Normal,afLightDir[0]) * 0.5f + 0.5f;\n"
+        "#define AV_LIGHT_0 afLightDir[0]\n"
         "#endif\n"
-            "float fHalfLambert = L1*L1;\n"
-            
+        "float fHalfLambert = L1*L1;\n"
+
         "#ifdef AV_DIFFUSE_TEXTURE\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert  * IN.Color.rgb +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert  * IN.Color.rgb +\n"
         "#else\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * fHalfLambert  * IN.Color.rgb +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * fHalfLambert  * IN.Color.rgb +\n"
         "#endif // !AV_DIFFUSE_TEXTURE\n"
 
         "#ifdef AV_SPECULAR_COMPONENT\n"
-            "#ifndef AV_SKYBOX_LOOKUP\n"
-                "#ifdef AV_SPECULAR_TEXTURE\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#else\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#endif // !AV_SPECULAR_TEXTURE\n"
-            "#else\n"
-                "#ifdef AV_SPECULAR_TEXTURE\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#else\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
-                "#endif // !AV_SPECULAR_TEXTURE\n"
-            "#endif // !AV_SKYBOX_LOOKUP\n"
+        "#ifndef AV_SKYBOX_LOOKUP\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#else\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#endif // !AV_SPECULAR_TEXTURE\n"
+        "#else\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#else\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_0),SPECULARITY)) + \n"
+        "#endif // !AV_SPECULAR_TEXTURE\n"
+        "#endif // !AV_SKYBOX_LOOKUP\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_AMBIENT_TEXTURE\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb + \n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb + \n"
         "#else\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb + \n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb + \n"
         "#endif // !AV_AMBIENT_TEXTURE\n"
         "#ifdef AV_EMISSIVE_TEXTURE\n"
-            "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
+        "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
         "#else \n"
-            "EMISSIVE_COLOR.rgb;\n"
+        "EMISSIVE_COLOR.rgb;\n"
         "#endif // !AV_EMISSIVE_TEXTURE\n"
         "}\n"
         "{\n"
         "#ifdef AV_NORMAL_TEXTURE\n"
-            "float L1 = dot(Normal,IN_Light1) * 0.5f + 0.5f;\n"
-            "#define AV_LIGHT_1 IN_Light1\n"
+        "float L1 = dot(Normal,IN_Light1) * 0.5f + 0.5f;\n"
+        "#define AV_LIGHT_1 IN_Light1\n"
         "#else\n"
-            "float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
-            "#define AV_LIGHT_1 afLightDir[1]\n"
+        "float L1 = dot(Normal,afLightDir[1]) * 0.5f + 0.5f;\n"
+        "#define AV_LIGHT_1 afLightDir[1]\n"
         "#endif\n"
-            "float fHalfLambert = L1*L1;\n"
+        "float fHalfLambert = L1*L1;\n"
         "#ifdef AV_DIFFUSE_TEXTURE\n"
-            "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert  * IN.Color.rgb +\n"
+        "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * fHalfLambert  * IN.Color.rgb +\n"
         "#else\n"
-            "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * fHalfLambert   * IN.Color.rgb +\n"
+        "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * fHalfLambert   * IN.Color.rgb +\n"
         "#endif // !AV_DIFFUSE_TEXTURE\n"
 
         "#ifdef AV_SPECULAR_COMPONENT\n"
-            "#ifndef AV_SKYBOX_LOOKUP\n"
-                "#ifdef AV_SPECULAR_TEXTURE\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
-                "#else\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
-                "#endif // !AV_SPECULAR_TEXTURE\n"
-            "#else\n"
-                "#ifdef AV_SPECULAR_TEXTURE\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
-                "#else\n"
-                    "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
-                "#endif // !AV_SPECULAR_TEXTURE\n"
-            "#endif // !AV_SKYBOX_LOOKUP\n"
+        "#ifndef AV_SKYBOX_LOOKUP\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
+        "#else\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
+        "#endif // !AV_SPECULAR_TEXTURE\n"
+        "#else\n"
+        "#ifdef AV_SPECULAR_TEXTURE\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * GetSSSCubeMap(Reflect) * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
+        "#else\n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * GetSSSCubeMap(Reflect) * (saturate(fHalfLambert * 2.0f) * pow(dot(Reflect,AV_LIGHT_1),SPECULARITY)) + \n"
+        "#endif // !AV_SPECULAR_TEXTURE\n"
+        "#endif // !AV_SKYBOX_LOOKUP\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_AMBIENT_TEXTURE\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb + \n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb + \n"
         "#else\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb + \n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb + \n"
         "#endif // !AV_AMBIENT_TEXTURE\n"
         "#ifdef AV_EMISSIVE_TEXTURE\n"
-            "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
+        "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
         "#else \n"
-            "EMISSIVE_COLOR.rgb;\n"
+        "EMISSIVE_COLOR.rgb;\n"
         "#endif // !AV_EMISSIVE_TEXTURE\n"
         "}\n"
         "#ifdef AV_OPACITY\n"
@@ -994,11 +985,11 @@ std::string g_szMaterialShader = std::string(
 
         "#undef AV_LIGHT_0\n"
         "#undef AV_LIGHT_1\n"
-    "}\n"
+        "}\n"
 
-    // Same pixel shader again, one light
-    "float4 MaterialPShaderSpecular_PS20_D1(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        // Same pixel shader again, one light
+        "float4 MaterialPShaderSpecular_PS20_D1(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "#ifdef AV_NORMAL_TEXTURE\n"
@@ -1018,27 +1009,27 @@ std::string g_szMaterialShader = std::string(
         "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
         "#endif\n"
         "#ifdef AV_DIFFUSE_TEXTURE\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
         "#else\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
         "#endif // !AV_DIFFUSE_TEXTURE\n"
 
         "#ifdef AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_SPECULAR_TEXTURE\n"
-            "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
         "#else\n"
-            "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
         "#endif // !AV_SPECULAR_TEXTURE\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_AMBIENT_TEXTURE\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
         "#else\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb +\n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb +\n"
         "#endif // !AV_AMBIENT_TEXTURE\n"
         "#ifdef AV_EMISSIVE_TEXTURE\n"
-            "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
+        "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
         "#else \n"
-            "EMISSIVE_COLOR.rgb;\n"
+        "EMISSIVE_COLOR.rgb;\n"
         "#endif // !AV_EMISSIVE_TEXTURE\n"
         "}\n"
 
@@ -1049,11 +1040,11 @@ std::string g_szMaterialShader = std::string(
         "OUT.a *= tex2D(OPACITY_SAMPLER,IN.TexCoord0). AV_OPACITY_TEXTURE_REGISTER_MASK;\n"
         "#endif\n"
         "return OUT;\n"
-    "}\n"
+        "}\n"
 
-    // Same pixel shader again, two lights
-    "float4 MaterialPShaderSpecular_PS20_D2(VS_OUTPUT IN) : COLOR\n"
-    "{\n"
+        // Same pixel shader again, two lights
+        "float4 MaterialPShaderSpecular_PS20_D2(VS_OUTPUT IN) : COLOR\n"
+        "{\n"
         "float4 OUT = float4(0.0f,0.0f,0.0f,1.0f);\n"
 
         "#ifdef AV_NORMAL_TEXTURE\n"
@@ -1074,27 +1065,27 @@ std::string g_szMaterialShader = std::string(
         "float3 Reflect = reflect (Normal,afLightDir[0]);\n"
         "#endif\n"
         "#ifdef AV_DIFFUSE_TEXTURE\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
         "#else\n"
-            "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
+        "OUT.rgb += afLightColor[0].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
         "#endif // !AV_DIFFUSE_TEXTURE\n"
 
         "#ifdef AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_SPECULAR_TEXTURE\n"
-            "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
         "#else\n"
-            "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[0].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
         "#endif // !AV_SPECULAR_TEXTURE\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_AMBIENT_TEXTURE\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
         "#else\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb +\n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[0].rgb +\n"
         "#endif // !AV_AMBIENT_TEXTURE\n"
         "#ifdef AV_EMISSIVE_TEXTURE\n"
-            "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
+        "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
         "#else \n"
-            "EMISSIVE_COLOR.rgb;\n"
+        "EMISSIVE_COLOR.rgb;\n"
         "#endif // !AV_EMISSIVE_TEXTURE\n"
         "}\n"
         "{\n"
@@ -1106,27 +1097,27 @@ std::string g_szMaterialShader = std::string(
         "float3 Reflect = reflect (Normal,afLightDir[1]);\n"
         "#endif\n"
         "#ifdef AV_DIFFUSE_TEXTURE\n"
-            "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
+        "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * tex2D(DIFFUSE_SAMPLER,IN.TexCoord0).rgb * L1 +\n"
         "#else\n"
-            "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
+        "OUT.rgb += afLightColor[1].rgb * DIFFUSE_COLOR.rgb * L1 +\n"
         "#endif // !AV_DIFFUSE_TEXTURE\n"
 
         "#ifdef AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_SPECULAR_TEXTURE\n"
-            "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * tex2D(SPECULAR_SAMPLER,IN.TexCoord0).rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
         "#else\n"
-            "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
+        "SPECULAR_COLOR.rgb * SPECULAR_STRENGTH * afLightColor[1].rgb * (saturate(L1 * 4.0f) * pow(dot(Reflect,ViewDir),SPECULARITY)) + \n"
         "#endif // !AV_SPECULAR_TEXTURE\n"
         "#endif // !AV_SPECULAR_COMPONENT\n"
         "#ifdef AV_AMBIENT_TEXTURE\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb * tex2D(AMBIENT_SAMPLER,IN.TexCoord0).rgb +\n"
         "#else\n"
-            "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb + \n"
+        "AMBIENT_COLOR.rgb * afLightColorAmbient[1].rgb + \n"
         "#endif // !AV_AMBIENT_TEXTURE\n"
         "#ifdef AV_EMISSIVE_TEXTURE\n"
-            "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
+        "EMISSIVE_COLOR.rgb * tex2D(EMISSIVE_SAMPLER,IN.TexCoord0).rgb;\n"
         "#else \n"
-            "EMISSIVE_COLOR.rgb;\n"
+        "EMISSIVE_COLOR.rgb;\n"
         "#endif // !AV_EMISSIVE_TEXTURE\n"
         "}\n"
 
@@ -1137,139 +1128,137 @@ std::string g_szMaterialShader = std::string(
         "OUT.a *= tex2D(OPACITY_SAMPLER,IN.TexCoord0). AV_OPACITY_TEXTURE_REGISTER_MASK;\n"
         "#endif\n"
         "return OUT;\n"
-    "}\n"
+        "}\n"
 
-
-    // Technique for the material effect
-    "technique MaterialFXSpecular_D1\n"
-    "{\n"
+        // Technique for the material effect
+        "technique MaterialFXSpecular_D1\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "#ifdef AV_OPACITY_TEXTURE\n"
-            "AlphaBlendEnable=TRUE;"
-            "SrcBlend = srcalpha;\n"
-            "DestBlend = invsrcalpha;\n"
-            "#else\n"
-            "#ifdef AV_OPACITY\n"
-            "AlphaBlendEnable=TRUE;"
-            "SrcBlend = srcalpha;\n"
-            "DestBlend = invsrcalpha;\n"
-            "#endif \n"
-            "#endif\n"
+        "#ifdef AV_OPACITY_TEXTURE\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#else\n"
+        "#ifdef AV_OPACITY\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#endif \n"
+        "#endif\n"
 
-            "PixelShader = compile ps_3_0 MaterialPShaderSpecular_D1();\n"
-            "VertexShader = compile vs_3_0 MaterialVShader_D1();\n"
+        "PixelShader = compile ps_3_0 MaterialPShaderSpecular_D1();\n"
+        "VertexShader = compile vs_3_0 MaterialVShader_D1();\n"
         "}\n"
-    "};\n"
-    "technique MaterialFXSpecular_D2\n"
-    "{\n"
+        "};\n"
+        "technique MaterialFXSpecular_D2\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "#ifdef AV_OPACITY_TEXTURE\n"
-            "AlphaBlendEnable=TRUE;"
-            "SrcBlend = srcalpha;\n"
-            "DestBlend = invsrcalpha;\n"
-            "#else\n"
-            "#ifdef AV_OPACITY\n"
-            "AlphaBlendEnable=TRUE;"
-            "SrcBlend = srcalpha;\n"
-            "DestBlend = invsrcalpha;\n"
-            "#endif \n"
-            "#endif\n"
+        "#ifdef AV_OPACITY_TEXTURE\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#else\n"
+        "#ifdef AV_OPACITY\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#endif \n"
+        "#endif\n"
 
-            "PixelShader = compile ps_3_0 MaterialPShaderSpecular_D2();\n"
-            "VertexShader = compile vs_3_0 MaterialVShader_D2();\n"
+        "PixelShader = compile ps_3_0 MaterialPShaderSpecular_D2();\n"
+        "VertexShader = compile vs_3_0 MaterialVShader_D2();\n"
         "}\n"
-    "};\n"
+        "};\n"
 
-    // Technique for the material effect (ps_2_0)
-    "technique MaterialFXSpecular_PS20_D1\n"
-    "{\n"
-        "pass p0\n"
-    "{\n"
-          "#ifdef AV_OPACITY_TEXTURE\n"
-          "AlphaBlendEnable=TRUE;"
-          "SrcBlend = srcalpha;\n"
-          "DestBlend = invsrcalpha;\n"
-          "#else\n"
-          "#ifdef AV_OPACITY\n"
-          "AlphaBlendEnable=TRUE;"
-          "SrcBlend = srcalpha;\n"
-          "DestBlend = invsrcalpha;\n"
-          "#endif \n"
-          "#endif\n"
-
-          "PixelShader = compile ps_2_0 MaterialPShaderSpecular_PS20_D1();\n"
-          "VertexShader = compile vs_2_0 MaterialVShader_D1();\n"
-        "}\n"
-    "};\n"
-
-    "technique MaterialFXSpecular_PS20_D2\n"
-    "{\n"
-        "pass p0\n"
-      "{\n"
-          "//CullMode=none;\n"
-
-          "#ifdef AV_OPACITY_TEXTURE\n"
-          "AlphaBlendEnable=TRUE;"
-          "SrcBlend = srcalpha;\n"
-          "DestBlend = invsrcalpha;\n"
-          "#else\n"
-          "#ifdef AV_OPACITY\n"
-          "AlphaBlendEnable=TRUE;"
-          "SrcBlend = srcalpha;\n"
-          "DestBlend = invsrcalpha;\n"
-          "#endif \n"
-          "#endif\n"
-
-          "PixelShader = compile ps_2_0 MaterialPShaderSpecular_PS20_D2();\n"
-          "VertexShader = compile vs_2_0 MaterialVShader_D2();\n"
-        "}\n"
-    "};\n"
-
-    // Technique for the material effect using fixed function pixel pipeline
-    "technique MaterialFX_FF\n"
-    "{\n"
+        // Technique for the material effect (ps_2_0)
+        "technique MaterialFXSpecular_PS20_D1\n"
+        "{\n"
         "pass p0\n"
         "{\n"
-            "//CullMode=none;\n"
-            "SpecularEnable = true; \n"
-            "VertexShader = compile vs_2_0 MaterialVShader_FF();\n"
-            "ColorOp[0] = Modulate;\n"
-            "ColorArg0[0] = Texture;\n"
-            "ColorArg1[0] = Diffuse;\n"
-            "AlphaOp[0] = Modulate;\n"
-            "AlphaArg0[0] = Texture;\n"
-            "AlphaArg1[0] = Diffuse;\n"
+        "#ifdef AV_OPACITY_TEXTURE\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#else\n"
+        "#ifdef AV_OPACITY\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#endif \n"
+        "#endif\n"
+
+        "PixelShader = compile ps_2_0 MaterialPShaderSpecular_PS20_D1();\n"
+        "VertexShader = compile vs_2_0 MaterialVShader_D1();\n"
         "}\n"
-    "};\n"
-    );
+        "};\n"
+
+        "technique MaterialFXSpecular_PS20_D2\n"
+        "{\n"
+        "pass p0\n"
+        "{\n"
+        "//CullMode=none;\n"
+
+        "#ifdef AV_OPACITY_TEXTURE\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#else\n"
+        "#ifdef AV_OPACITY\n"
+        "AlphaBlendEnable=TRUE;"
+        "SrcBlend = srcalpha;\n"
+        "DestBlend = invsrcalpha;\n"
+        "#endif \n"
+        "#endif\n"
+
+        "PixelShader = compile ps_2_0 MaterialPShaderSpecular_PS20_D2();\n"
+        "VertexShader = compile vs_2_0 MaterialVShader_D2();\n"
+        "}\n"
+        "};\n"
+
+        // Technique for the material effect using fixed function pixel pipeline
+        "technique MaterialFX_FF\n"
+        "{\n"
+        "pass p0\n"
+        "{\n"
+        "//CullMode=none;\n"
+        "SpecularEnable = true; \n"
+        "VertexShader = compile vs_2_0 MaterialVShader_FF();\n"
+        "ColorOp[0] = Modulate;\n"
+        "ColorArg0[0] = Texture;\n"
+        "ColorArg1[0] = Diffuse;\n"
+        "AlphaOp[0] = Modulate;\n"
+        "AlphaArg0[0] = Texture;\n"
+        "AlphaArg1[0] = Diffuse;\n"
+        "}\n"
+        "};\n");
 
 std::string g_szPassThroughShader = std::string(
         "texture TEXTURE_2D;\n"
         "sampler TEXTURE_SAMPLER = sampler_state\n"
         "{\n"
-            "Texture = (TEXTURE_2D);\n"
-            "MinFilter = POINT;\n"
-            "MagFilter = POINT;\n"
+        "Texture = (TEXTURE_2D);\n"
+        "MinFilter = POINT;\n"
+        "MagFilter = POINT;\n"
         "};\n"
 
-    // Vertex Shader output for pixel shader usage
+        // Vertex Shader output for pixel shader usage
         "struct VS_OUTPUT\n"
         "{\n"
-            "float4 Position : POSITION;\n"
-            "float2 TexCoord0 : TEXCOORD0;\n"
+        "float4 Position : POSITION;\n"
+        "float2 TexCoord0 : TEXCOORD0;\n"
         "};\n"
 
-    // vertex shader for pixel shader usage
+        // vertex shader for pixel shader usage
         "VS_OUTPUT DefaultVShader(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
         "{\n"
-            "VS_OUTPUT Out;\n"
+        "VS_OUTPUT Out;\n"
 
-            "Out.Position = INPosition;\n"
-            "Out.TexCoord0 = INTexCoord0;\n"
+        "Out.Position = INPosition;\n"
+        "Out.TexCoord0 = INTexCoord0;\n"
 
-            "return Out;\n"
+        "return Out;\n"
         "}\n"
 
         // simply lookup a texture
@@ -1293,69 +1282,68 @@ std::string g_szPassThroughShader = std::string(
         // Simple pass-through technique
         "technique PassThrough\n"
         "{\n"
-            "pass p0\n"
-            "{\n"
-                "FillMode=Solid;\n"
-                "ZEnable = FALSE;\n"
-                "CullMode = none;\n"
-                "AlphaBlendEnable = TRUE;\n"
-                "SrcBlend =srcalpha;\n"
-                "DestBlend =invsrcalpha;\n"
-                "PixelShader = compile ps_2_0 PassThrough_PS();\n"
-                "VertexShader = compile vs_2_0 DefaultVShader();\n"
-            "}\n"
+        "pass p0\n"
+        "{\n"
+        "FillMode=Solid;\n"
+        "ZEnable = FALSE;\n"
+        "CullMode = none;\n"
+        "AlphaBlendEnable = TRUE;\n"
+        "SrcBlend =srcalpha;\n"
+        "DestBlend =invsrcalpha;\n"
+        "PixelShader = compile ps_2_0 PassThrough_PS();\n"
+        "VertexShader = compile vs_2_0 DefaultVShader();\n"
+        "}\n"
         "};\n"
 
         // Pass-through technique which visualizes the texture's alpha channel
         "technique PassThroughAlphaFromA\n"
         "{\n"
-            "pass p0\n"
-            "{\n"
-                "FillMode=Solid;\n"
-                "ZEnable = FALSE;\n"
-                "CullMode = none;\n"
-                "AlphaBlendEnable = TRUE;\n"
-                "SrcBlend =srcalpha;\n"
-                "DestBlend =invsrcalpha;\n"
-                "PixelShader = compile ps_2_0 PassThroughAlphaA_PS();\n"
-                "VertexShader = compile vs_2_0 DefaultVShader();\n"
-            "}\n"
+        "pass p0\n"
+        "{\n"
+        "FillMode=Solid;\n"
+        "ZEnable = FALSE;\n"
+        "CullMode = none;\n"
+        "AlphaBlendEnable = TRUE;\n"
+        "SrcBlend =srcalpha;\n"
+        "DestBlend =invsrcalpha;\n"
+        "PixelShader = compile ps_2_0 PassThroughAlphaA_PS();\n"
+        "VertexShader = compile vs_2_0 DefaultVShader();\n"
+        "}\n"
         "};\n"
 
         // Pass-through technique which visualizes the texture's red channel
         "technique PassThroughAlphaFromR\n"
         "{\n"
-            "pass p0\n"
-            "{\n"
-                "FillMode=Solid;\n"
-                "ZEnable = FALSE;\n"
-                "CullMode = none;\n"
-                "AlphaBlendEnable = TRUE;\n"
-                "SrcBlend =srcalpha;\n"
-                "DestBlend =invsrcalpha;\n"
-                "PixelShader = compile ps_2_0 PassThroughAlphaR_PS();\n"
-                "VertexShader = compile vs_2_0 DefaultVShader();\n"
-            "}\n"
+        "pass p0\n"
+        "{\n"
+        "FillMode=Solid;\n"
+        "ZEnable = FALSE;\n"
+        "CullMode = none;\n"
+        "AlphaBlendEnable = TRUE;\n"
+        "SrcBlend =srcalpha;\n"
+        "DestBlend =invsrcalpha;\n"
+        "PixelShader = compile ps_2_0 PassThroughAlphaR_PS();\n"
+        "VertexShader = compile vs_2_0 DefaultVShader();\n"
+        "}\n"
         "};\n"
 
         // technique for fixed function pixel pipeline
         "technique PassThrough_FF\n"
         "{\n"
-            "pass p0\n"
-            "{\n"
-                "ZEnable = FALSE;\n"
-                "CullMode = none;\n"
-                "AlphaBlendEnable = TRUE;\n"
-                "SrcBlend =srcalpha;\n"
-                "DestBlend =invsrcalpha;\n"
-                "VertexShader = compile vs_2_0 DefaultVShader();\n"
+        "pass p0\n"
+        "{\n"
+        "ZEnable = FALSE;\n"
+        "CullMode = none;\n"
+        "AlphaBlendEnable = TRUE;\n"
+        "SrcBlend =srcalpha;\n"
+        "DestBlend =invsrcalpha;\n"
+        "VertexShader = compile vs_2_0 DefaultVShader();\n"
         "ColorOp[0] = SelectArg1;\n"
         "ColorArg0[0] = Texture;\n"
         "AlphaOp[0] = SelectArg1;\n"
         "AlphaArg0[0] = Texture;\n"
-            "}\n"
-        "};\n"
-    );
+        "}\n"
+        "};\n");
 
 std::string g_szCheckerBackgroundShader = std::string(
 
@@ -1366,45 +1354,44 @@ std::string g_szCheckerBackgroundShader = std::string(
         // size of a square in both x and y direction
         "float SQUARE_SIZE = 10.0f;\n"
 
-    // vertex shader output structure
+        // vertex shader output structure
         "struct VS_OUTPUT\n"
         "{\n"
-            "float4 Position : POSITION;\n"	
+        "float4 Position : POSITION;\n"
         "};\n"
 
-    // vertex shader 
+        // vertex shader
         "VS_OUTPUT DefaultVShader(float4 INPosition : POSITION, float2 INTexCoord0 : TEXCOORD0 )\n"
         "{\n"
-            "VS_OUTPUT Out;\n"
+        "VS_OUTPUT Out;\n"
 
-            "Out.Position = INPosition;\n"
-            "return Out;\n"
+        "Out.Position = INPosition;\n"
+        "return Out;\n"
         "}\n"
 
         // pixel shader
         "float4 MakePattern_PS(float2 IN : VPOS) : COLOR\n"
         "{\n"
-          "float2 fDiv = IN / SQUARE_SIZE;\n"
-          "float3 fColor = COLOR_ONE;\n"
-          "if (0 == round(fmod(round(fDiv.x),2)))\n"
-          "{\n"
-          "  if (0 == round(fmod(round(fDiv.y),2))) fColor = COLOR_TWO;\n"
-          "}\n"
-          "else if (0 != round(fmod(round(fDiv.y),2)))fColor = COLOR_TWO;\n"
-          "return float4(fColor,1.0f);"
+        "float2 fDiv = IN / SQUARE_SIZE;\n"
+        "float3 fColor = COLOR_ONE;\n"
+        "if (0 == round(fmod(round(fDiv.x),2)))\n"
+        "{\n"
+        "  if (0 == round(fmod(round(fDiv.y),2))) fColor = COLOR_TWO;\n"
         "}\n"
-    
+        "else if (0 != round(fmod(round(fDiv.y),2)))fColor = COLOR_TWO;\n"
+        "return float4(fColor,1.0f);"
+        "}\n"
+
         // technique to generate a pattern
         "technique MakePattern\n"
         "{\n"
-          "pass p0\n"
-          "{\n"
-            "FillMode=Solid;\n"
-            "ZEnable = FALSE;\n"
-            "CullMode = none;\n"
-            "PixelShader = compile ps_3_0 MakePattern_PS();\n"
-            "VertexShader = compile vs_3_0 DefaultVShader();\n"
-          "}\n"
-        "};\n"
-        );
-    };
\ No newline at end of file
+        "pass p0\n"
+        "{\n"
+        "FillMode=Solid;\n"
+        "ZEnable = FALSE;\n"
+        "CullMode = none;\n"
+        "PixelShader = compile ps_3_0 MakePattern_PS();\n"
+        "VertexShader = compile vs_3_0 DefaultVShader();\n"
+        "}\n"
+        "};\n");
+}; // namespace AssimpView
diff --git a/tools/assimp_view/assimp_view.h b/tools/assimp_view/assimp_view.h
index 3c519bb92..2adffacff 100644
--- a/tools/assimp_view/assimp_view.h
+++ b/tools/assimp_view/assimp_view.h
@@ -5,8 +5,6 @@ Open Asset Import Library (assimp)
 
 Copyright (c) 2006-2020, assimp team
 
-
-
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,