Merge branch 'master' into FBXMeshGeometry_checksizes_fix

.github/FUNDING.yml

@@ -1,2 +1,2 @@
 patreon: assimp
-ko_fi: kimkulling
+Paypal: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4JRJVPXC4QJM4

CMakeLists.txt

@@ -41,13 +41,13 @@ CMAKE_MINIMUM_REQUIRED( VERSION 3.0 )
 # Toggles the use of the hunter package manager
 option(HUNTER_ENABLED "Enable Hunter package manager support" OFF)
 
-include("cmake/HunterGate.cmake")
+IF(HUNTER_ENABLED)
-HunterGate(
+  include("cmake/HunterGate.cmake")
+  HunterGate(
     URL "https://github.com/ruslo/hunter/archive/v0.23.176.tar.gz"
     SHA1 "2e9ae973d028660b735ac4c6142725ca36a0048a"
-)
+  )
 
-IF(HUNTER_ENABLED)
   add_definitions(-DASSIMP_USE_HUNTER)
 ENDIF(HUNTER_ENABLED)
 
@@ -437,7 +437,9 @@ ELSE(HUNTER_ENABLED)
     DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT})
 ENDIF(HUNTER_ENABLED)
 
-FIND_PACKAGE( DirectX )
+if (ASSIMP_BUILD_SAMPLES OR ASSIMP_BUILD_SAMPLES)
+  FIND_PACKAGE(DirectX)
+endif(ASSIMP_BUILD_SAMPLES OR ASSIMP_BUILD_SAMPLES)
 
 IF( BUILD_DOCS )
   ADD_SUBDIRECTORY(doc)

code/CMakeLists.txt

@@ -198,6 +198,7 @@ SET( Common_SRCS
   Common/CreateAnimMesh.cpp
   Common/simd.h
   Common/simd.cpp
+  Common/material.cpp
 )
 SOURCE_GROUP(Common FILES ${Common_SRCS})
 

code/Common/assbin_chunks.h

@@ -37,7 +37,7 @@ The ASSBIN file format is composed of chunks to represent the hierarchical aiSce
 This makes the format extensible and allows backward-compatibility with future data structure
 versions. The <tt>&lt;root&gt;/code/assbin_chunks.h</tt> header contains some magic constants
 for use by stand-alone ASSBIN loaders. Also, Assimp's own file writer can be found
-in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDumb.cpp</tt> (yes, the 'b' is no typo ...).
+in <tt>&lt;root&gt;/tools/assimp_cmd/WriteDump.cpp</tt> (yes, the 'b' is no typo ...).
 
 @verbatim
 

code/Common/material.cpp

@@ -0,0 +1,97 @@
+/*
+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 material.cpp
+/** Implement common material related functions. */
+
+#include <assimp/ai_assert.h>
+#include <assimp/material.h>
+
+// -------------------------------------------------------------------------------
+const char* TextureTypeToString(aiTextureType in)
+{
+    switch (in)
+    {
+    case aiTextureType_NONE:
+        return "n/a";
+    case aiTextureType_DIFFUSE:
+        return "Diffuse";
+    case aiTextureType_SPECULAR:
+        return "Specular";
+    case aiTextureType_AMBIENT:
+        return "Ambient";
+    case aiTextureType_EMISSIVE:
+        return "Emissive";
+    case aiTextureType_OPACITY:
+        return "Opacity";
+    case aiTextureType_NORMALS:
+        return "Normals";
+    case aiTextureType_HEIGHT:
+        return "Height";
+    case aiTextureType_SHININESS:
+        return "Shininess";
+    case aiTextureType_DISPLACEMENT:
+        return "Displacement";
+    case aiTextureType_LIGHTMAP:
+        return "Lightmap";
+    case aiTextureType_REFLECTION:
+        return "Reflection";
+    case aiTextureType_BASE_COLOR:
+        return "BaseColor";
+    case aiTextureType_NORMAL_CAMERA:
+        return "NormalCamera";
+    case aiTextureType_EMISSION_COLOR:
+        return "EmissionColor";
+    case aiTextureType_METALNESS:
+        return "Metalness";
+    case aiTextureType_DIFFUSE_ROUGHNESS:
+        return "DiffuseRoughness";
+    case aiTextureType_AMBIENT_OCCLUSION:
+        return "AmbientOcclusion";
+    case aiTextureType_UNKNOWN:
+        return "Unknown";
+    default:
+        break;
+    }
+    ai_assert(false);
+    return "BUG";
+}

code/FBX/FBXParser.cpp

@@ -367,9 +367,13 @@ float ParseTokenAsFloat(const Token& t, const char*& err_out)
     // first - next in the fbx token stream comes ',',
     // which fast_atof could interpret as decimal point.
 #define MAX_FLOAT_LENGTH 31
-    char temp[MAX_FLOAT_LENGTH + 1];
     const size_t length = static_cast<size_t>(t.end()-t.begin());
-    std::copy(t.begin(),t.end(),temp);
+    if (length > MAX_FLOAT_LENGTH) {
+        return 0.f;
+    }
+
+    char temp[MAX_FLOAT_LENGTH + 1];
+    std::copy(t.begin(), t.end(), temp);
     temp[std::min(static_cast<size_t>(MAX_FLOAT_LENGTH),length)] = '\0';
 
     return fast_atof(temp);

code/M3D/M3DImporter.cpp

@@ -109,7 +109,9 @@ using namespace std;
 // ------------------------------------------------------------------------------------------------
 //  Default constructor
 M3DImporter::M3DImporter() :
-		mScene(nullptr) {}
+		mScene(nullptr) {
+			// empty
+		}
 
 // ------------------------------------------------------------------------------------------------
 //  Returns true, if file is a binary or ASCII Model 3D file.
@@ -225,7 +227,7 @@ void M3DImporter::InternReadFile(const std::string &file, aiScene *pScene, IOSys
 
 // ------------------------------------------------------------------------------------------------
 // convert materials. properties are converted using a static table in M3DMaterials.h
-void M3DImporter::importMaterials(const M3DWrapper &m3d_wrap) {
+void M3DImporter::importMaterials(const M3DWrapper &m3d) {
 	unsigned int i, j, k, l, n;
 	m3dm_t *m;
 	aiString name = aiString(AI_DEFAULT_MATERIAL_NAME);
@@ -233,9 +235,9 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d_wrap) {
 	ai_real f;
 
 	ai_assert(mScene != nullptr);
-	ai_assert(m3d_wrap);
+	ai_assert(m3d);
 
-	mScene->mNumMaterials = m3d_wrap->nummaterial + 1;
+	mScene->mNumMaterials = m3d->nummaterial + 1;
 	mScene->mMaterials = new aiMaterial *[mScene->mNumMaterials];
 
 	ASSIMP_LOG_DEBUG_F("M3D: importMaterials ", mScene->mNumMaterials);
@@ -248,8 +250,12 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d_wrap) {
 	mat->AddProperty(&c, 1, AI_MATKEY_COLOR_DIFFUSE);
 	mScene->mMaterials[0] = mat;
 
-	for (i = 0; i < m3d_wrap->nummaterial; i++) {
+	if (!m3d->nummaterial || !m3d->material) {
-		m = &m3d_wrap->material[i];
+		return;
+	}
+
+	for (i = 0; i < m3d->nummaterial; i++) {
+		m = &m3d->material[i];
 		aiMaterial *mat = new aiMaterial;
 		name.Set(std::string(m->name));
 		mat->AddProperty(&name, AI_MATKEY_NAME);
@@ -294,9 +300,9 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d_wrap) {
 			// texture map properties
 			if (m->prop[j].type >= 128 && aiTxProps[k].pKey &&
 					// extra check, should never happen, do we have the refered texture?
-					m->prop[j].value.textureid < m3d_wrap->numtexture &&
+					m->prop[j].value.textureid < m3d->numtexture &&
-					m3d_wrap->texture[m->prop[j].value.textureid].name) {
+					m3d->texture[m->prop[j].value.textureid].name) {
-				name.Set(std::string(std::string(m3d_wrap->texture[m->prop[j].value.textureid].name) + ".png"));
+				name.Set(std::string(std::string(m3d->texture[m->prop[j].value.textureid].name) + ".png"));
 				mat->AddProperty(&name, aiTxProps[k].pKey, aiTxProps[k].type, aiTxProps[k].index);
 				n = 0;
 				mat->AddProperty(&n, 1, _AI_MATKEY_UVWSRC_BASE, aiProps[k].type, aiProps[k].index);
@@ -310,7 +316,12 @@ void M3DImporter::importMaterials(const M3DWrapper &m3d_wrap) {
 // import textures, this is the simplest of all
 void M3DImporter::importTextures(const M3DWrapper &m3d) {
 	unsigned int i;
-	const char *formatHint[] = { "rgba0800", "rgba0808", "rgba8880", "rgba8888" };
+	const char *formatHint[] = {
+		"rgba0800",
+		"rgba0808",
+		"rgba8880",
+		"rgba8888"
+	};
 	m3dtx_t *t;
 
 	ai_assert(mScene != nullptr);
@@ -319,8 +330,9 @@ void M3DImporter::importTextures(const M3DWrapper &m3d) {
 	mScene->mNumTextures = m3d->numtexture;
 	ASSIMP_LOG_DEBUG_F("M3D: importTextures ", mScene->mNumTextures);
 
-	if (!m3d->numtexture)
+	if (!m3d->numtexture || !m3d->texture) {
 		return;
+	}
 
 	mScene->mTextures = new aiTexture *[m3d->numtexture];
 	for (i = 0; i < m3d->numtexture; i++) {
@@ -371,7 +383,13 @@ void M3DImporter::importTextures(const M3DWrapper &m3d) {
 // individually. In assimp there're per mesh vertex and UV lists, and they must be
 // indexed simultaneously.
 void M3DImporter::importMeshes(const M3DWrapper &m3d) {
-	unsigned int i, j, k, l, numpoly = 3, lastMat = M3D_INDEXMAX;
+	ASSIMP_LOG_DEBUG_F("M3D: importMeshes ", m3d->numface);
+
+	if (!m3d->numface || !m3d->face || !m3d->numvertex || !m3d->vertex) {
+		return;
+	}
+
+    unsigned int i, j, k, l, numpoly = 3, lastMat = M3D_INDEXMAX;
 	std::vector<aiMesh *> *meshes = new std::vector<aiMesh *>();
 	std::vector<aiFace> *faces = nullptr;
 	std::vector<aiVector3D> *vertices = nullptr;
@@ -385,7 +403,6 @@ void M3DImporter::importMeshes(const M3DWrapper &m3d) {
 	ai_assert(m3d);
 	ai_assert(mScene->mRootNode != nullptr);
 
-	ASSIMP_LOG_DEBUG_F("M3D: importMeshes ", m3d->numface);
 
 	for (i = 0; i < m3d->numface; i++) {
 		// we must switch mesh if material changes
@@ -420,6 +437,7 @@ void M3DImporter::importMeshes(const M3DWrapper &m3d) {
 			k = static_cast<unsigned int>(vertices->size());
 			pFace->mIndices[j] = k;
 			l = m3d->face[i].vertex[j];
+			if(l >= m3d->numvertex) continue;
 			pos.x = m3d->vertex[l].x;
 			pos.y = m3d->vertex[l].y;
 			pos.z = m3d->vertex[l].z;
@@ -432,14 +450,14 @@ void M3DImporter::importMeshes(const M3DWrapper &m3d) {
 				vertexids->push_back(l);
 			}
 			l = m3d->face[i].texcoord[j];
-			if (l != M3D_UNDEF) {
+			if (l != M3D_UNDEF && l < m3d->numtmap) {
 				uv.x = m3d->tmap[l].u;
 				uv.y = m3d->tmap[l].v;
 				uv.z = 0.0;
 				texcoords->push_back(uv);
 			}
 			l = m3d->face[i].normal[j];
-			if (l != M3D_UNDEF) {
+			if (l != M3D_UNDEF && l < m3d->numvertex) {
 				norm.x = m3d->vertex[l].x;
 				norm.y = m3d->vertex[l].y;
 				norm.z = m3d->vertex[l].z;
@@ -487,8 +505,15 @@ void M3DImporter::importBones(const M3DWrapper &m3d, unsigned int parentid, aiNo
 
 	ASSIMP_LOG_DEBUG_F("M3D: importBones ", m3d->numbone, " parentid ", (int)parentid);
 
-	for (n = 0, i = parentid + 1; i < m3d->numbone; i++)
+	if (!m3d->numbone || !m3d->bone) {
-		if (m3d->bone[i].parent == parentid) n++;
+		return;
+	}
+
+	for (n = 0, i = parentid + 1; i < m3d->numbone; i++) {
+		if (m3d->bone[i].parent == parentid) {
+			n++;
+		}
+	}
 	pParent->mChildren = new aiNode *[n];
 
 	for (i = parentid + 1; i < m3d->numbone; i++) {
@@ -521,8 +546,9 @@ void M3DImporter::importAnimations(const M3DWrapper &m3d) {
 
 	ASSIMP_LOG_DEBUG_F("M3D: importAnimations ", mScene->mNumAnimations);
 
-	if (!m3d->numaction || !m3d->numbone)
+	if (!m3d->numaction || !m3d->action || !m3d->numbone || !m3d->bone || !m3d->vertex) {
 		return;
+	}
 
 	mScene->mAnimations = new aiAnimation *[m3d->numaction];
 	for (i = 0; i < m3d->numaction; i++) {
@@ -552,6 +578,7 @@ void M3DImporter::importAnimations(const M3DWrapper &m3d) {
 						ori = a->frame[j].transform[k].ori;
 					}
 				}
+				if(pos >= m3d->numvertex || ori >= m3d->numvertex) continue;
 				m3dv_t *v = &m3d->vertex[pos];
 				m3dv_t *q = &m3d->vertex[ori];
 				pAnim->mChannels[l]->mPositionKeys[j].mTime = t;
@@ -587,6 +614,8 @@ void M3DImporter::convertPose(const M3DWrapper &m3d, aiMatrix4x4 *m, unsigned in
 	ai_assert(m3d);
 	ai_assert(posid != M3D_UNDEF && posid < m3d->numvertex);
 	ai_assert(orientid != M3D_UNDEF && orientid < m3d->numvertex);
+	if (!m3d->numvertex || !m3d->vertex)
+		return;
 	m3dv_t *p = &m3d->vertex[posid];
 	m3dv_t *q = &m3d->vertex[orientid];
 
@@ -629,16 +658,18 @@ void M3DImporter::convertPose(const M3DWrapper &m3d, aiMatrix4x4 *m, unsigned in
 // ------------------------------------------------------------------------------------------------
 // find a node by name
 aiNode *M3DImporter::findNode(aiNode *pNode, aiString name) {
-	unsigned int i;
-
 	ai_assert(pNode != nullptr);
 	ai_assert(mScene != nullptr);
 
-	if (pNode->mName == name)
+	if (pNode->mName == name) {
 		return pNode;
-	for (i = 0; i < pNode->mNumChildren; i++) {
+	}
+
+	for (unsigned int i = 0; i < pNode->mNumChildren; i++) {
 		aiNode *pChild = findNode(pNode->mChildren[i], name);
-		if (pChild) return pChild;
+		if (pChild) {
+			return pChild;
+		}
 	}
 	return nullptr;
 }
@@ -700,8 +731,8 @@ void M3DImporter::populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector
 		// this is complicated, because M3D stores a list of bone id / weight pairs per
 		// vertex but assimp uses lists of local vertex id/weight pairs per local bone list
 		pMesh->mNumBones = m3d->numbone;
-		/* we need aiBone with mOffsetMatrix for bones without weights as well */
+		// we need aiBone with mOffsetMatrix for bones without weights as well
-		if (pMesh->mNumBones) {
+		if (pMesh->mNumBones && m3d->numbone && m3d->bone) {
 			pMesh->mBones = new aiBone *[pMesh->mNumBones];
 			for (unsigned int i = 0; i < m3d->numbone; i++) {
 				aiNode *pNode;
@@ -715,10 +746,13 @@ void M3DImporter::populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector
 				} else
 					pMesh->mBones[i]->mOffsetMatrix = aiMatrix4x4();
 			}
-			if (vertexids->size()) {
+			if (vertexids->size() && m3d->numvertex && m3d->vertex && m3d->numskin && m3d->skin) {
 				unsigned int i, j;
 				// first count how many vertices we have per bone
 				for (i = 0; i < vertexids->size(); i++) {
+					if(vertexids->at(i) >= m3d->numvertex) {
+						continue;
+					}
 					unsigned int s = m3d->vertex[vertexids->at(i)].skinid;
 					if (s != M3D_UNDEF && s != M3D_INDEXMAX) {
 						for (unsigned int k = 0; k < M3D_NUMBONE && m3d->skin[s].weight[k] > 0.0; k++) {
@@ -742,9 +776,11 @@ void M3DImporter::populateMesh(const M3DWrapper &m3d, aiMesh *pMesh, std::vector
 				}
 				// fill up with data
 				for (i = 0; i < vertexids->size(); i++) {
+					if(vertexids->at(i) >= m3d->numvertex) continue;
 					unsigned int s = m3d->vertex[vertexids->at(i)].skinid;
-					if (s != M3D_UNDEF && s != M3D_INDEXMAX) {
+					if (s != M3D_UNDEF && s != M3D_INDEXMAX && s < m3d->numskin) {
 						for (unsigned int k = 0; k < M3D_NUMBONE && m3d->skin[s].weight[k] > 0.0; k++) {
+							if(m3d->skin[s].boneid[k] >= m3d->numbone) continue;
 							aiString name = aiString(std::string(m3d->bone[m3d->skin[s].boneid[k]].name));
 							for (j = 0; j < pMesh->mNumBones; j++) {
 								if (pMesh->mBones[j]->mName == name) {

code/MDL/HalfLife/HL1MDLLoader.cpp

@@ -340,39 +340,13 @@ void HL1MDLLoader::load_sequence_groups_files() {
 }
 
 // ------------------------------------------------------------------------------------------------
-/** @brief Read an MDL texture.
+// Read an MDL texture.
-*
-*   @note This method is taken from HL1 source code.
-*   source: file: studio_utils.c
-*           function(s): UploadTexture
-*/
 void HL1MDLLoader::read_texture(const Texture_HL1 *ptexture,
         uint8_t *data, uint8_t *pal, aiTexture *pResult,
         aiColor3D &last_palette_color) {
-    int outwidth, outheight;
-    int i, j;
-    static const size_t BuffenLen = 256;
-    int row1[BuffenLen], row2[BuffenLen], col1[BuffenLen], col2[BuffenLen];
-    unsigned char *pix1, *pix2, *pix3, *pix4;
-
-    // convert texture to power of 2
-    for (outwidth = 1; outwidth < ptexture->width; outwidth <<= 1)
-        ;
-
-    if ( outwidth > static_cast<int>(BuffenLen)) {
-        outwidth = BuffenLen;
-    }
-
-    for (outheight = 1; outheight < ptexture->height; outheight <<= 1)
-        ;
-
-    if (static_cast<size_t>(outheight) > BuffenLen) {
-        outheight = BuffenLen;
-    }
-
     pResult->mFilename = ptexture->name;
-    pResult->mWidth = outwidth;
+    pResult->mWidth = static_cast<unsigned int>(ptexture->width);
-    pResult->mHeight = outheight;
+    pResult->mHeight = static_cast<unsigned int>(ptexture->height);
     pResult->achFormatHint[0] = 'r';
     pResult->achFormatHint[1] = 'g';
     pResult->achFormatHint[2] = 'b';
@@ -383,31 +357,15 @@ void HL1MDLLoader::read_texture(const Texture_HL1 *ptexture,
     pResult->achFormatHint[7] = '8';
     pResult->achFormatHint[8] = '\0';
 
-    aiTexel *out = pResult->pcData = new aiTexel[outwidth * outheight];
+    const size_t num_pixels = pResult->mWidth * pResult->mHeight;
+    aiTexel *out = pResult->pcData = new aiTexel[num_pixels];
 
-    for (i = 0; i < outwidth; i++) {
+    // Convert indexed 8 bit to 32 bit RGBA.
-        col1[i] = (int)((i + 0.25) * (ptexture->width / (float)outwidth));
+    for (size_t i = 0; i < num_pixels; ++i, ++out) {
-        col2[i] = (int)((i + 0.75) * (ptexture->width / (float)outwidth));
+        out->r = pal[data[i] * 3];
-    }
+        out->g = pal[data[i] * 3 + 1];
-
+        out->b = pal[data[i] * 3 + 2];
-    for (i = 0; i < outheight; i++) {
+        out->a = 255;
-        row1[i] = (int)((i + 0.25) * (ptexture->height / (float)outheight)) * ptexture->width;
-        row2[i] = (int)((i + 0.75) * (ptexture->height / (float)outheight)) * ptexture->width;
-    }
-
-    // scale down and convert to 32bit RGB
-    for (i = 0; i < outheight; i++) {
-        for (j = 0; j < outwidth; j++, out++) {
-            pix1 = &pal[data[row1[i] + col1[j]] * 3];
-            pix2 = &pal[data[row1[i] + col2[j]] * 3];
-            pix3 = &pal[data[row2[i] + col1[j]] * 3];
-            pix4 = &pal[data[row2[i] + col2[j]] * 3];
-
-            out->r = (pix1[0] + pix2[0] + pix3[0] + pix4[0]) >> 2;
-            out->g = (pix1[1] + pix2[1] + pix3[1] + pix4[1]) >> 2;
-            out->b = (pix1[2] + pix2[2] + pix3[2] + pix4[2]) >> 2;
-            out->a = 0xFF;
-        }
     }
 
     // Get the last palette color.

code/PostProcessing/ArmaturePopulate.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,
@@ -36,7 +35,6 @@ 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.
-
 ----------------------------------------------------------------------
 */
 #include "ArmaturePopulate.h"
@@ -50,219 +48,215 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 
 /// The default class constructor.
-ArmaturePopulate::ArmaturePopulate() : BaseProcess()
+ArmaturePopulate::ArmaturePopulate() :
-{}
+        BaseProcess() {
+    // do nothing
+}
 
 /// The class destructor.
-ArmaturePopulate::~ArmaturePopulate() 
+ArmaturePopulate::~ArmaturePopulate() {
-{}
+    // do nothing
+}
 
 bool ArmaturePopulate::IsActive(unsigned int pFlags) const {
-  return (pFlags & aiProcess_PopulateArmatureData) != 0;
+    return (pFlags & aiProcess_PopulateArmatureData) != 0;
 }
 
 void ArmaturePopulate::SetupProperties(const Importer *pImp) {
-  // do nothing
+    // do nothing
 }
 
 void ArmaturePopulate::Execute(aiScene *out) {
 
-  // Now convert all bone positions to the correct mOffsetMatrix
+    // Now convert all bone positions to the correct mOffsetMatrix
-  std::vector<aiBone *> bones;
+    std::vector<aiBone *> bones;
-  std::vector<aiNode *> nodes;
+    std::vector<aiNode *> nodes;
-  std::map<aiBone *, aiNode *> bone_stack;
+    std::map<aiBone *, aiNode *> bone_stack;
-  BuildBoneList(out->mRootNode, out->mRootNode, out, bones);
+    BuildBoneList(out->mRootNode, out->mRootNode, out, bones);
-  BuildNodeList(out->mRootNode, nodes);
+    BuildNodeList(out->mRootNode, nodes);
 
-  BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
+    BuildBoneStack(out->mRootNode, out->mRootNode, out, bones, bone_stack, nodes);
 
-  ASSIMP_LOG_DEBUG_F("Bone stack size: ", bone_stack.size());
+    ASSIMP_LOG_DEBUG_F("Bone stack size: ", bone_stack.size());
 
-  for (std::pair<aiBone *, aiNode *> kvp : bone_stack) {
+    for (std::pair<aiBone *, aiNode *> kvp : bone_stack) {
-    aiBone *bone = kvp.first;
+        aiBone *bone = kvp.first;
-    aiNode *bone_node = kvp.second;
+        aiNode *bone_node = kvp.second;
-    ASSIMP_LOG_DEBUG_F("active node lookup: ", bone->mName.C_Str());
+        ASSIMP_LOG_DEBUG_F("active node lookup: ", bone->mName.C_Str());
-    // lcl transform grab - done in generate_nodes :)
+        // lcl transform grab - done in generate_nodes :)
 
-    // bone->mOffsetMatrix = bone_node->mTransformation;
+        // bone->mOffsetMatrix = bone_node->mTransformation;
-    aiNode *armature = GetArmatureRoot(bone_node, bones);
+        aiNode *armature = GetArmatureRoot(bone_node, bones);
 
-    ai_assert(armature);
+        ai_assert(armature);
 
-    // set up bone armature id
+        // set up bone armature id
-    bone->mArmature = armature;
+        bone->mArmature = armature;
 
-    // set this bone node to be referenced properly
+        // set this bone node to be referenced properly
-    ai_assert(bone_node);
+        ai_assert(bone_node);
-    bone->mNode = bone_node;
+        bone->mNode = bone_node;
-  }
+    }
 }
 
 
-/* Reprocess all nodes to calculate bone transforms properly based on the REAL
+// Reprocess all nodes to calculate bone transforms properly based on the REAL
- * mOffsetMatrix not the local. */
+// mOffsetMatrix not the local.
-/* Before this would use mesh transforms which is wrong for bone transforms */
+// Before this would use mesh transforms which is wrong for bone transforms
-/* Before this would work for simple character skeletons but not complex meshes
+// Before this would work for simple character skeletons but not complex meshes
- * with multiple origins */
+// with multiple origins
-/* Source: sketch fab log cutter fbx */
+// Source: sketch fab log cutter fbx
 void ArmaturePopulate::BuildBoneList(aiNode *current_node,
                                      const aiNode *root_node,
                                      const aiScene *scene,
                                      std::vector<aiBone *> &bones) {
-  ai_assert(scene);
+    ai_assert(scene);
-  for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
+    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-    aiNode *child = current_node->mChildren[nodeId];
+        aiNode *child = current_node->mChildren[nodeId];
-    ai_assert(child);
+        ai_assert(child);
 
-    // check for bones
+        // check for bones
-    for (unsigned int meshId = 0; meshId < child->mNumMeshes; ++meshId) {
+        for (unsigned int meshId = 0; meshId < child->mNumMeshes; ++meshId) {
-      ai_assert(child->mMeshes);
+            ai_assert(child->mMeshes);
-      unsigned int mesh_index = child->mMeshes[meshId];
+            unsigned int mesh_index = child->mMeshes[meshId];
-      aiMesh *mesh = scene->mMeshes[mesh_index];
+            aiMesh *mesh = scene->mMeshes[mesh_index];
-      ai_assert(mesh);
+            ai_assert(mesh);
 
-      for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
+            for (unsigned int boneId = 0; boneId < mesh->mNumBones; ++boneId) {
-        aiBone *bone = mesh->mBones[boneId];
+                aiBone *bone = mesh->mBones[boneId];
-        ai_assert(bone);
+                ai_assert(bone);
 
-        // duplicate meshes exist with the same bones sometimes :)
+                // duplicate mehes exist with the same bones sometimes :)
-        // so this must be detected
+                // so this must be detected
-        if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
+                if (std::find(bones.begin(), bones.end(), bone) == bones.end()) {
-          // add the element once
+                    // add the element once
-          bones.push_back(bone);
+                    bones.push_back(bone);
+                }
+            }
+
+            // find mesh and get bones
+            // then do recursive lookup for bones in root node hierarchy
         }
-      }
 
-      // find mesh and get bones
+        BuildBoneList(child, root_node, scene, bones);
-      // then do recursive lookup for bones in root node hierarchy
     }
-
-    BuildBoneList(child, root_node, scene, bones);
-  }
 }
 
-/* Prepare flat node list which can be used for non recursive lookups later */
+// Prepare flat node list which can be used for non recursive lookups later
 void ArmaturePopulate::BuildNodeList(const aiNode *current_node,
                                      std::vector<aiNode *> &nodes) {
-  ai_assert(current_node);
+    ai_assert(current_node);
 
-  for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
+    for (unsigned int nodeId = 0; nodeId < current_node->mNumChildren; ++nodeId) {
-    aiNode *child = current_node->mChildren[nodeId];
+        aiNode *child = current_node->mChildren[nodeId];
-    ai_assert(child);
+        ai_assert(child);
 
-    nodes.push_back(child);
+        if (child->mNumMeshes == 0) {
+            nodes.push_back(child);
+        }
 
-    BuildNodeList(child, nodes);
+        BuildNodeList(child, nodes);
   }
 }
 
-/* A bone stack allows us to have multiple armatures, with the same bone names
+// A bone stack allows us to have multiple armatures, with the same bone names
- * A bone stack allows us also to retrieve bones true transform even with
+// A bone stack allows us also to retrieve bones true transform even with
- * duplicate names :)
+// duplicate names :)
- */
 void ArmaturePopulate::BuildBoneStack(aiNode *current_node,
                                       const aiNode *root_node,
                                       const aiScene *scene,
                                       const std::vector<aiBone *> &bones,
                                       std::map<aiBone *, aiNode *> &bone_stack,
-                                      std::vector<aiNode *> &node_stack) {
+                                  std::vector<aiNode *> &node_stack) {
-  ai_assert(scene);
+    ai_assert(scene);
-  ai_assert(root_node);
+    ai_assert(root_node);
-  ai_assert(!node_stack.empty());
+    ai_assert(!node_stack.empty());
 
-  for (aiBone *bone : bones) {
+    for (aiBone *bone : bones) {
-    ai_assert(bone);
+        ai_assert(bone);
-    aiNode *node = GetNodeFromStack(bone->mName, node_stack);
+        aiNode *node = GetNodeFromStack(bone->mName, node_stack);
-    if (node == nullptr) {
+        if (node == nullptr) {
-      node_stack.clear();
+            node_stack.clear();
-      BuildNodeList(root_node, node_stack);
+            BuildNodeList(root_node, node_stack);
-      ASSIMP_LOG_DEBUG_F("Resetting bone stack: nullptr element ", bone->mName.C_Str());
+            ASSIMP_LOG_DEBUG_F("Resetting bone stack: nullptr element ", bone->mName.C_Str());
 
-      node = GetNodeFromStack(bone->mName, node_stack);
+            node = GetNodeFromStack(bone->mName, node_stack);
 
-      if (!node) {
+            if (!node) {
-        ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
+                ASSIMP_LOG_ERROR("serious import issue node for bone was not detected");
-        continue;
+                continue;
-      }
+            }
+        }
+
+        ASSIMP_LOG_DEBUG_F("Successfully added bone[", bone->mName.C_Str(), "] to stack and bone node is: ", node->mName.C_Str());
+
+        bone_stack.insert(std::pair<aiBone *, aiNode *>(bone, node));
     }
-
-    ASSIMP_LOG_DEBUG_F("Successfully added bone[", bone->mName.C_Str(), "] to stack and bone node is: ", node->mName.C_Str());
-
-    bone_stack.insert(std::pair<aiBone *, aiNode *>(bone, node));
-  }
 }
 
-
+// Returns the armature root node
-/* Returns the armature root node */
+// This is required to be detected for a bone initially, it will recurse up
-/* This is required to be detected for a bone initially, it will recurse up
+// until it cannot find another bone and return the node No known failure
- * until it cannot find another bone and return the node No known failure
+// points. (yet)
- * points. (yet)
- */
 aiNode *ArmaturePopulate::GetArmatureRoot(aiNode *bone_node,
                                           std::vector<aiBone *> &bone_list) {
-  while (bone_node) {
+    while (bone_node) {
-    if (!IsBoneNode(bone_node->mName, bone_list)) {
+        if (!IsBoneNode(bone_node->mName, bone_list)) {
-      ASSIMP_LOG_DEBUG_F("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
+            ASSIMP_LOG_DEBUG_F("GetArmatureRoot() Found valid armature: ", bone_node->mName.C_Str());
-      return bone_node;
+            return bone_node;
+        }
+
+        bone_node = bone_node->mParent;
     }
 
-    bone_node = bone_node->mParent;
+    ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
-  }
+
-  
+    return nullptr;
-  ASSIMP_LOG_ERROR("GetArmatureRoot() can't find armature!");
-  
-  return nullptr;
 }
 
-
+// Simple IsBoneNode check if this could be a bone
-
-/* Simple IsBoneNode check if this could be a bone */
 bool ArmaturePopulate::IsBoneNode(const aiString &bone_name,
                                   std::vector<aiBone *> &bones) {
-  for (aiBone *bone : bones) {
+    for (aiBone *bone : bones) {
-    if (bone->mName == bone_name) {
+        if (bone->mName == bone_name) {
-      return true;
+            return true;
+        }
     }
-  }
 
-  return false;
+    return false;
 }
 
-/* Pop this node by name from the stack if found */
+// Pop this node by name from the stack if found
-/* Used in multiple armature situations with duplicate node / bone names */
+// Used in multiple armature situations with duplicate node / bone names
-/* Known flaw: cannot have nodes with bone names, will be fixed in later release
+// Known flaw: cannot have nodes with bone names, will be fixed in later release
- */
+// (serious to be fixed) Known flaw: nodes which have more than one bone could
-/* (serious to be fixed) Known flaw: nodes which have more than one bone could
+// be prematurely dropped from stack
- * be prematurely dropped from stack */
 aiNode *ArmaturePopulate::GetNodeFromStack(const aiString &node_name,
                                            std::vector<aiNode *> &nodes) {
-  std::vector<aiNode *>::iterator iter;
+    std::vector<aiNode *>::iterator iter;
-  aiNode *found = nullptr;
+    aiNode *found = nullptr;
-  for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
+    for (iter = nodes.begin(); iter < nodes.end(); ++iter) {
-    aiNode *element = *iter;
+        aiNode *element = *iter;
-    ai_assert(element);
+        ai_assert(element);
-    // node valid and node name matches
+        // node valid and node name matches
-    if (element->mName == node_name) {
+        if (element->mName == node_name) {
-      found = element;
+            found = element;
-      break;
+            break;
+        }
     }
-  }
 
-  if (found != nullptr) {
+    if (found != nullptr) {
-    ASSIMP_LOG_INFO_F("Removed node from stack: ", found->mName.C_Str());
+        ASSIMP_LOG_INFO_F("Removed node from stack: ", found->mName.C_Str());
-    // now pop the element from the node list
+        // now pop the element from the node list
-    nodes.erase(iter);
+        nodes.erase(iter);
 
-    return found;
+        return found;
-  }
+    }
 
-  // unique names can cause this problem
+    // unique names can cause this problem
-  ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
+    ASSIMP_LOG_ERROR("[Serious] GetNodeFromStack() can't find node from stack!");
 
-  return nullptr;
+    return nullptr;
 }
 
-
-
-
 } // Namespace Assimp

code/PostProcessing/ProcessHelper.cpp

@@ -230,46 +230,6 @@ VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh)
     return avPerVertexWeights;
 }
 
-
-// -------------------------------------------------------------------------------
-const char* TextureTypeToString(aiTextureType in)
-{
-    switch (in)
-    {
-    case aiTextureType_NONE:
-        return "n/a";
-    case aiTextureType_DIFFUSE:
-        return "Diffuse";
-    case aiTextureType_SPECULAR:
-        return "Specular";
-    case aiTextureType_AMBIENT:
-        return "Ambient";
-    case aiTextureType_EMISSIVE:
-        return "Emissive";
-    case aiTextureType_OPACITY:
-        return "Opacity";
-    case aiTextureType_NORMALS:
-        return "Normals";
-    case aiTextureType_HEIGHT:
-        return "Height";
-    case aiTextureType_SHININESS:
-        return "Shininess";
-    case aiTextureType_DISPLACEMENT:
-        return "Displacement";
-    case aiTextureType_LIGHTMAP:
-        return "Lightmap";
-    case aiTextureType_REFLECTION:
-        return "Reflection";
-    case aiTextureType_UNKNOWN:
-        return "Unknown";
-    default:
-        break;
-    }
-
-    ai_assert(false);
-    return  "BUG";
-}
-
 // -------------------------------------------------------------------------------
 const char* MappingTypeToString(aiTextureMapping in)
 {

code/PostProcessing/ProcessHelper.h

@@ -316,12 +316,6 @@ typedef std::vector <PerVertexWeight> VertexWeightTable;
 // Compute a per-vertex bone weight table
 VertexWeightTable* ComputeVertexBoneWeightTable(const aiMesh* pMesh);
 
-
-// -------------------------------------------------------------------------------
-// Get a string for a given aiTextureType
-const char* TextureTypeToString(aiTextureType in);
-
-
 // -------------------------------------------------------------------------------
 // Get a string for a given aiTextureMapping
 const char* MappingTypeToString(aiTextureMapping in);

code/glTF/glTFExporter.cpp

@@ -352,6 +352,8 @@ void glTFExporter::GetMatColorOrTex(const aiMaterial* mat, glTF::TexProperty& pr
 
                     if (path[0] == '*') { // embedded
                         aiTexture* tex = mScene->mTextures[atoi(&path[1])];
+						
+                        prop.texture->source->name = tex->mFilename.C_Str();
 
                         uint8_t* data = reinterpret_cast<uint8_t*>(tex->pcData);
                         prop.texture->source->SetData(data, tex->mWidth, *mAsset);

code/glTF/glTFImporter.cpp

@@ -680,6 +680,7 @@ void glTFImporter::ImportEmbeddedTextures(glTF::Asset& r)
         size_t length = img.GetDataLength();
         void* data = img.StealData();
 
+        tex->mFilename = img.name;
         tex->mWidth = static_cast<unsigned int>(length);
         tex->mHeight = 0;
         tex->pcData = reinterpret_cast<aiTexel*>(data);

code/glTF2/glTF2Exporter.cpp

@@ -351,6 +351,8 @@ void glTF2Exporter::GetMatTex(const aiMaterial* mat, Ref<Texture>& texture, aiTe
 
                     if (path[0] == '*') { // embedded
                         aiTexture* tex = mScene->mTextures[atoi(&path[1])];
+						
+                        texture->source->name = tex->mFilename.C_Str();
 
                         // The asset has its own buffer, see Image::SetData
                         texture->source->SetData(reinterpret_cast<uint8_t*> (tex->pcData), tex->mWidth, *mAsset);

code/glTF2/glTF2Importer.cpp

@@ -1248,6 +1248,7 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
 		size_t length = img.GetDataLength();
 		void *data = img.StealData();
 
+		tex->mFilename = img.name;
 		tex->mWidth = static_cast<unsigned int>(length);
 		tex->mHeight = 0;
 		tex->pcData = reinterpret_cast<aiTexel *>(data);

include/assimp/material.h

@@ -312,6 +312,10 @@ enum aiTextureType
 
 #define AI_TEXTURE_TYPE_MAX  aiTextureType_UNKNOWN
 
+// -------------------------------------------------------------------------------
+// Get a string for a given aiTextureType
+ASSIMP_API const char* TextureTypeToString(enum aiTextureType in);
+
 // ---------------------------------------------------------------------------
 /** @brief Defines all shading models supported by the library
  *

tools/assimp_cmd/CMakeLists.txt

@@ -54,7 +54,7 @@ ADD_EXECUTABLE( assimp_cmd
   Main.cpp
   Main.h
   resource.h
-  WriteDumb.cpp
+  WriteDump.cpp
   Info.cpp
   Export.cpp
 )

tools/assimp_cmd/Info.cpp

@@ -444,6 +444,12 @@ int Assimp_Info (const char* const* params, unsigned int num) {
 			aiTextureType_DISPLACEMENT,
 			aiTextureType_LIGHTMAP,
 			aiTextureType_REFLECTION,
+			aiTextureType_BASE_COLOR,
+			aiTextureType_NORMAL_CAMERA,
+			aiTextureType_EMISSION_COLOR,
+			aiTextureType_METALNESS,
+			aiTextureType_DIFFUSE_ROUGHNESS,
+			aiTextureType_AMBIENT_OCCLUSION,
 			aiTextureType_UNKNOWN
 		};
 		for(unsigned int type = 0; type < sizeof(types)/sizeof(types[0]); ++type) {

tools/assimp_cmd/Main.h

@@ -168,7 +168,7 @@ bool ExportModel(const aiScene* pOut,
 
 // ------------------------------------------------------------------------------
 /** assimp_dump utility
- *  @param params Command line parameters to 'assimp dumb'
+ *  @param params Command line parameters to 'assimp dump'
  *  @param Number of params
  *  @return An #AssimpCmdError value.*/
 int Assimp_Dump (

tools/assimp_cmd/WriteDump.cpp

@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-/** @file  WriteTextDumb.cpp
+/** @file  WriteDump.cpp
  *  @brief Implementation of the 'assimp dump' utility
  */
 
@@ -69,44 +69,6 @@ const char* AICMD_MSG_DUMP_HELP =
 FILE* out = NULL;
 bool shortened = false;
 
-// -------------------------------------------------------------------------------
-const char* TextureTypeToString(aiTextureType in)
-{
-	switch (in)
-	{
-	case aiTextureType_NONE:
-		return "n/a";
-	case aiTextureType_DIFFUSE:
-		return "Diffuse";
-	case aiTextureType_SPECULAR:
-		return "Specular";
-	case aiTextureType_AMBIENT:
-		return "Ambient";
-	case aiTextureType_EMISSIVE:
-		return "Emissive";
-	case aiTextureType_OPACITY:
-		return "Opacity";
-	case aiTextureType_NORMALS:
-		return "Normals";
-	case aiTextureType_HEIGHT:
-		return "Height";
-	case aiTextureType_SHININESS:
-		return "Shininess";
-	case aiTextureType_DISPLACEMENT:
-		return "Displacement";
-	case aiTextureType_LIGHTMAP:
-		return "Lightmap";
-	case aiTextureType_REFLECTION:
-		return "Reflection";
-	case aiTextureType_UNKNOWN:
-		return "Unknown";
-	default:
-		break;
-	}
-	ai_assert(false); 
-	return  "BUG";    
-}
-
 // -----------------------------------------------------------------------------------
 int Assimp_Dump (const char* const* params, unsigned int num)
 {