v4games
/
assimp
3
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge pull request #4426 from sacereda/info-material-properties 

Add properties information on assimp info command line
pull/4431/head^2
Kim Kulling 2022-03-15 11:57:58 +01:00 committed by GitHub
parent e1dae1402e b567497a17
commit 7296ffc3f5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 368 additions and 346 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

714
tools/assimp_cmd/Info.cpp
View File

@ -50,12 +50,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <iostream> #include <iostream>
#include <string> #include <string>
const char* AICMD_MSG_INFO_HELP_E = const char *AICMD_MSG_INFO_HELP_E =
"assimp info <file> [-r] [-v]\n" "assimp info <file> [-r] [-v]\n"
"\tPrint basic structure of a 3D model\n" "\tPrint basic structure of a 3D model\n"
"\t-r,--raw: No postprocessing, do a raw import\n" "\t-r,--raw: No postprocessing, do a raw import\n"
"\t-v,--verbose: Print verbose info such as node transform data\n" "\t-v,--verbose: Print verbose info such as node transform data\n"
"\t-s, --silent: Print only minimal info\n"; "\t-s, --silent: Print only minimal info\n";
const char *TREE_BRANCH_ASCII = "|-"; const char *TREE_BRANCH_ASCII = "|-";
const char *TREE_BRANCH_UTF8 = "\xe2\x94\x9c\xe2\x95\xb4"; const char *TREE_BRANCH_UTF8 = "\xe2\x94\x9c\xe2\x95\xb4";
@ -73,411 +73,433 @@ const char *TREE_STOP = TREE_STOP_UTF8;
const char *TREE_CONTINUE = TREE_CONTINUE_UTF8; const char *TREE_CONTINUE = TREE_CONTINUE_UTF8;
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int CountNodes(const aiNode* root) unsigned int CountNodes(const aiNode *root) {
{ unsigned int i = 0;
unsigned int i = 0; for (unsigned int a = 0; a < root->mNumChildren; ++a) {
for (unsigned int a = 0; a < root->mNumChildren; ++a ) { i += CountNodes(root->mChildren[a]);
i += CountNodes(root->mChildren[a]); }
} return 1 + i;
return 1+i;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int GetMaxDepth(const aiNode* root) unsigned int GetMaxDepth(const aiNode *root) {
{ unsigned int cnt = 0;
unsigned int cnt = 0; for (unsigned int i = 0; i < root->mNumChildren; ++i) {
for (unsigned int i = 0; i < root->mNumChildren; ++i ) { cnt = std::max(cnt, GetMaxDepth(root->mChildren[i]));
cnt = std::max(cnt,GetMaxDepth(root->mChildren[i])); }
} return cnt + 1;
return cnt+1;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int CountVertices(const aiScene* scene) unsigned int CountVertices(const aiScene *scene) {
{ unsigned int cnt = 0;
unsigned int cnt = 0; for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
for(unsigned int i = 0; i < scene->mNumMeshes; ++i) { cnt += scene->mMeshes[i]->mNumVertices;
cnt += scene->mMeshes[i]->mNumVertices; }
} return cnt;
return cnt;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int CountFaces(const aiScene* scene) unsigned int CountFaces(const aiScene *scene) {
{ unsigned int cnt = 0;
unsigned int cnt = 0; for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
for(unsigned int i = 0; i < scene->mNumMeshes; ++i) { cnt += scene->mMeshes[i]->mNumFaces;
cnt += scene->mMeshes[i]->mNumFaces; }
} return cnt;
return cnt;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int CountBones(const aiScene* scene) unsigned int CountBones(const aiScene *scene) {
{ unsigned int cnt = 0;
unsigned int cnt = 0; for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
for(unsigned int i = 0; i < scene->mNumMeshes; ++i) { cnt += scene->mMeshes[i]->mNumBones;
cnt += scene->mMeshes[i]->mNumBones; }
} return cnt;
return cnt;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int CountAnimChannels(const aiScene* scene) unsigned int CountAnimChannels(const aiScene *scene) {
{ unsigned int cnt = 0;
unsigned int cnt = 0; for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
for(unsigned int i = 0; i < scene->mNumAnimations; ++i) { cnt += scene->mAnimations[i]->mNumChannels;
cnt += scene->mAnimations[i]->mNumChannels; }
} return cnt;
return cnt;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int GetAvgFacePerMesh(const aiScene* scene) { unsigned int GetAvgFacePerMesh(const aiScene *scene) {
return (scene->mNumMeshes != 0) ? static_cast<unsigned int>(CountFaces(scene)/scene->mNumMeshes) : 0; return (scene->mNumMeshes != 0) ? static_cast<unsigned int>(CountFaces(scene) / scene->mNumMeshes) : 0;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int GetAvgVertsPerMesh(const aiScene* scene) { unsigned int GetAvgVertsPerMesh(const aiScene *scene) {
return (scene->mNumMeshes != 0) ? static_cast<unsigned int>(CountVertices(scene)/scene->mNumMeshes) : 0; return (scene->mNumMeshes != 0) ? static_cast<unsigned int>(CountVertices(scene) / scene->mNumMeshes) : 0;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void FindSpecialPoints(const aiScene* scene,const aiNode* root,aiVector3D special_points[3],const aiMatrix4x4& mat=aiMatrix4x4()) void FindSpecialPoints(const aiScene *scene, const aiNode *root, aiVector3D special_points[3], const aiMatrix4x4 &mat = aiMatrix4x4()) {
{ // XXX that could be greatly simplified by using code from code/ProcessHelper.h
// XXX that could be greatly simplified by using code from code/ProcessHelper.h // XXX I just don't want to include it here.
// XXX I just don't want to include it here. const aiMatrix4x4 trafo = root->mTransformation * mat;
const aiMatrix4x4 trafo = root->mTransformation*mat; for (unsigned int i = 0; i < root->mNumMeshes; ++i) {
for(unsigned int i = 0; i < root->mNumMeshes; ++i) { const aiMesh *mesh = scene->mMeshes[root->mMeshes[i]];
const aiMesh* mesh = scene->mMeshes[root->mMeshes[i]];
for(unsigned int a = 0; a < mesh->mNumVertices; ++a) { for (unsigned int a = 0; a < mesh->mNumVertices; ++a) {
aiVector3D v = trafo*mesh->mVertices[a]; aiVector3D v = trafo * mesh->mVertices[a];
special_points[0].x = std::min(special_points[0].x,v.x); special_points[0].x = std::min(special_points[0].x, v.x);
special_points[0].y = std::min(special_points[0].y,v.y); special_points[0].y = std::min(special_points[0].y, v.y);
special_points[0].z = std::min(special_points[0].z,v.z); special_points[0].z = std::min(special_points[0].z, v.z);
special_points[1].x = std::max(special_points[1].x,v.x); special_points[1].x = std::max(special_points[1].x, v.x);
special_points[1].y = std::max(special_points[1].y,v.y); special_points[1].y = std::max(special_points[1].y, v.y);
special_points[1].z = std::max(special_points[1].z,v.z); special_points[1].z = std::max(special_points[1].z, v.z);
} }
} }
for(unsigned int i = 0; i < root->mNumChildren; ++i) { for (unsigned int i = 0; i < root->mNumChildren; ++i) {
FindSpecialPoints(scene,root->mChildren[i],special_points,trafo); FindSpecialPoints(scene, root->mChildren[i], special_points, trafo);
} }
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
void FindSpecialPoints(const aiScene* scene,aiVector3D special_points[3]) void FindSpecialPoints(const aiScene *scene, aiVector3D special_points[3]) {
{ special_points[0] = aiVector3D(1e10, 1e10, 1e10);
special_points[0] = aiVector3D(1e10,1e10,1e10); special_points[1] = aiVector3D(-1e10, -1e10, -1e10);
special_points[1] = aiVector3D(-1e10,-1e10,-1e10);
FindSpecialPoints(scene,scene->mRootNode,special_points); FindSpecialPoints(scene, scene->mRootNode, special_points);
special_points[2] = (special_points[0]+special_points[1])*(ai_real)0.5; special_points[2] = (special_points[0] + special_points[1]) * (ai_real)0.5;
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
std::string FindPTypes(const aiScene* scene) std::string FindPTypes(const aiScene *scene) {
{ bool haveit[4] = { 0 };
bool haveit[4] = {0}; for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
for(unsigned int i = 0; i < scene->mNumMeshes; ++i) { const unsigned int pt = scene->mMeshes[i]->mPrimitiveTypes;
const unsigned int pt = scene->mMeshes[i]->mPrimitiveTypes; if (pt & aiPrimitiveType_POINT) {
if (pt & aiPrimitiveType_POINT) { haveit[0] = true;
haveit[0]=true; }
} if (pt & aiPrimitiveType_LINE) {
if (pt & aiPrimitiveType_LINE) { haveit[1] = true;
haveit[1]=true; }
} if (pt & aiPrimitiveType_TRIANGLE) {
if (pt & aiPrimitiveType_TRIANGLE) { haveit[2] = true;
haveit[2]=true; }
} if (pt & aiPrimitiveType_POLYGON) {
if (pt & aiPrimitiveType_POLYGON) { haveit[3] = true;
haveit[3]=true; }
} }
} return (haveit[0] ? std::string("points") : "") + (haveit[1] ? "lines" : "") +
return (haveit[0]?std::string("points"):"")+(haveit[1]?"lines":"")+ (haveit[2] ? "triangles" : "") + (haveit[3] ? "n-polygons" : "");
(haveit[2]?"triangles":"")+(haveit[3]?"n-polygons":"");
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Prettily print the node graph to stdout // Prettily print the node graph to stdout
void PrintHierarchy( void PrintHierarchy(
const aiNode* node, const aiNode *node,
const std::string &indent, const std::string &indent,
bool verbose, bool verbose,
bool last = false, bool last = false,
bool first = true bool first = true) {
){ // tree visualization
// tree visualization std::string branchchar;
std::string branchchar; if (first) {
if (first) { branchchar = ""; } branchchar = "";
else if (last) { branchchar = TREE_STOP; } // "'-" } else if (last) {
else { branchchar = TREE_BRANCH; } // "|-" branchchar = TREE_STOP;
} // "'-"
else {
branchchar = TREE_BRANCH;
} // "|-"
// print the indent and the branch character and the name // print the indent and the branch character and the name
std::cout << indent << branchchar << node->mName.C_Str(); std::cout << indent << branchchar << node->mName.C_Str();
// if there are meshes attached, indicate this // if there are meshes attached, indicate this
if (node->mNumMeshes) { if (node->mNumMeshes) {
std::cout << " (mesh "; std::cout << " (mesh ";
bool sep = false; bool sep = false;
for (size_t i=0; i < node->mNumMeshes; ++i) { for (size_t i = 0; i < node->mNumMeshes; ++i) {
unsigned int mesh_index = node->mMeshes[i]; unsigned int mesh_index = node->mMeshes[i];
if (sep) { std::cout << ", "; } if (sep) {
std::cout << mesh_index; std::cout << ", ";
sep = true; }
} std::cout << mesh_index;
std::cout << ")"; sep = true;
} }
std::cout << ")";
}
// finish the line // finish the line
std::cout << std::endl; std::cout << std::endl;
// in verbose mode, print the transform data as well // in verbose mode, print the transform data as well
if (verbose) { if (verbose) {
// indent to use // indent to use
std::string indentadd; std::string indentadd;
if (last) { indentadd += " "; } if (last) {
else { indentadd += TREE_CONTINUE; } // "| ".. indentadd += " ";
if (node->mNumChildren == 0) { indentadd += " "; } } else {
else { indentadd += TREE_CONTINUE; } // .."| " indentadd += TREE_CONTINUE;
aiVector3D s, r, t; } // "| "..
node->mTransformation.Decompose(s, r, t); if (node->mNumChildren == 0) {
if (s.x != 1.0 || s.y != 1.0 || s.z != 1.0) { indentadd += " ";
std::cout << indent << indentadd; } else {
printf(" S:[%f %f %f]\n", s.x, s.y, s.z); indentadd += TREE_CONTINUE;
} } // .."| "
if (r.x || r.y || r.z) { aiVector3D s, r, t;
std::cout << indent << indentadd; node->mTransformation.Decompose(s, r, t);
printf(" R:[%f %f %f]\n", r.x, r.y, r.z); if (s.x != 1.0 || s.y != 1.0 || s.z != 1.0) {
} std::cout << indent << indentadd;
if (t.x || t.y || t.z) { printf(" S:[%f %f %f]\n", s.x, s.y, s.z);
std::cout << indent << indentadd; }
printf(" T:[%f %f %f]\n", t.x, t.y, t.z); if (r.x || r.y || r.z) {
} std::cout << indent << indentadd;
} printf(" R:[%f %f %f]\n", r.x, r.y, r.z);
}
if (t.x || t.y || t.z) {
std::cout << indent << indentadd;
printf(" T:[%f %f %f]\n", t.x, t.y, t.z);
}
}
// and recurse // and recurse
std::string nextIndent; std::string nextIndent;
if (first) { nextIndent = indent; } if (first) {
else if (last) { nextIndent = indent + " "; } nextIndent = indent;
else { nextIndent = indent + TREE_CONTINUE; } // "| " } else if (last) {
for (size_t i = 0; i < node->mNumChildren; ++i) { nextIndent = indent + " ";
bool lastone = (i == node->mNumChildren - 1); } else {
PrintHierarchy( nextIndent = indent + TREE_CONTINUE;
node->mChildren[i], } // "| "
nextIndent, for (size_t i = 0; i < node->mNumChildren; ++i) {
verbose, bool lastone = (i == node->mNumChildren - 1);
lastone, PrintHierarchy(
false node->mChildren[i],
); nextIndent,
} verbose,
lastone,
false);
}
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// Implementation of the assimp info utility to print basic file info // Implementation of the assimp info utility to print basic file info
int Assimp_Info (const char* const* params, unsigned int num) { int Assimp_Info(const char *const *params, unsigned int num) {
// --help // --help
if (!strcmp( params[0],"-h")||!strcmp( params[0],"--help")||!strcmp( params[0],"-?") ) { if (!strcmp(params[0], "-h") || !strcmp(params[0], "--help") || !strcmp(params[0], "-?")) {
printf("%s",AICMD_MSG_INFO_HELP_E); printf("%s", AICMD_MSG_INFO_HELP_E);
return AssimpCmdError::Success; return AssimpCmdError::Success;
} }
// asssimp info <file> [-r] // asssimp info <file> [-r]
if (num < 1) { if (num < 1) {
printf("assimp info: Invalid number of arguments. " printf("assimp info: Invalid number of arguments. "
"See \'assimp info --help\'\n"); "See \'assimp info --help\'\n");
return AssimpCmdError::InvalidNumberOfArguments; return AssimpCmdError::InvalidNumberOfArguments;
} }
const std::string in = std::string(params[0]); const std::string in = std::string(params[0]);
// get -r and -v arguments // get -r and -v arguments
bool raw = false; bool raw = false;
bool verbose = false; bool verbose = false;
bool silent = false; bool silent = false;
for(unsigned int i = 1; i < num; ++i) { for (unsigned int i = 1; i < num; ++i) {
if (!strcmp(params[i],"--raw")||!strcmp(params[i],"-r")) { if (!strcmp(params[i], "--raw") || !strcmp(params[i], "-r")) {
raw = true; raw = true;
} }
if (!strcmp(params[i],"--verbose")||!strcmp(params[i],"-v")) { if (!strcmp(params[i], "--verbose") || !strcmp(params[i], "-v")) {
verbose = true; verbose = true;
} }
if (!strcmp(params[i], "--silent") || !strcmp(params[i], "-s")) { if (!strcmp(params[i], "--silent") || !strcmp(params[i], "-s")) {
silent = true; silent = true;
} }
} }
// Verbose and silent at the same time are not allowed // Verbose and silent at the same time are not allowed
if ( verbose && silent ) { if (verbose && silent) {
printf("assimp info: Invalid arguments, verbose and silent at the same time are forbidden. "); printf("assimp info: Invalid arguments, verbose and silent at the same time are forbidden. ");
return AssimpCmdInfoError::InvalidCombinaisonOfArguments; return AssimpCmdInfoError::InvalidCombinaisonOfArguments;
} }
// Parse post-processing flags unless -r was specified // Parse post-processing flags unless -r was specified
ImportData import; ImportData import;
if (!raw) { if (!raw) {
// get import flags // get import flags
ProcessStandardArguments(import, params + 1, num - 1); ProcessStandardArguments(import, params + 1, num - 1);
//No custom post process flags defined, we set all the post process flags active //No custom post process flags defined, we set all the post process flags active
if(import.ppFlags == 0) if (import.ppFlags == 0)
import.ppFlags |= aiProcessPreset_TargetRealtime_MaxQuality; import.ppFlags |= aiProcessPreset_TargetRealtime_MaxQuality;
} }
// import the main model // import the main model
const aiScene* scene = ImportModel(import,in); const aiScene *scene = ImportModel(import, in);
if (!scene) { if (!scene) {
printf("assimp info: Unable to load input file %s\n", printf("assimp info: Unable to load input file %s\n",
in.c_str()); in.c_str());
return AssimpCmdError::FailedToLoadInputFile; return AssimpCmdError::FailedToLoadInputFile;
} }
aiMemoryInfo mem; aiMemoryInfo mem;
globalImporter->GetMemoryRequirements(mem); globalImporter->GetMemoryRequirements(mem);
static const char *format_string =
"Memory consumption: %i B\n"
"Nodes: %i\n"
"Maximum depth %i\n"
"Meshes: %i\n"
"Animations: %i\n"
"Textures (embed.): %i\n"
"Materials: %i\n"
"Cameras: %i\n"
"Lights: %i\n"
"Vertices: %i\n"
"Faces: %i\n"
"Bones: %i\n"
"Animation Channels: %i\n"
"Primitive Types: %s\n"
"Average faces/mesh %i\n"
"Average verts/mesh %i\n"
"Minimum point (%f %f %f)\n"
"Maximum point (%f %f %f)\n"
"Center point (%f %f %f)\n"
static const char* format_string = ;
"Memory consumption: %i B\n"
"Nodes: %i\n"
"Maximum depth %i\n"
"Meshes: %i\n"
"Animations: %i\n"
"Textures (embed.): %i\n"
"Materials: %i\n"
"Cameras: %i\n"
"Lights: %i\n"
"Vertices: %i\n"
"Faces: %i\n"
"Bones: %i\n"
"Animation Channels: %i\n"
"Primitive Types: %s\n"
"Average faces/mesh %i\n"
"Average verts/mesh %i\n"
"Minimum point (%f %f %f)\n"
"Maximum point (%f %f %f)\n"
"Center point (%f %f %f)\n"
; aiVector3D special_points[3];
FindSpecialPoints(scene, special_points);
printf(format_string,
mem.total,
CountNodes(scene->mRootNode),
GetMaxDepth(scene->mRootNode),
scene->mNumMeshes,
scene->mNumAnimations,
scene->mNumTextures,
scene->mNumMaterials,
scene->mNumCameras,
scene->mNumLights,
CountVertices(scene),
CountFaces(scene),
CountBones(scene),
CountAnimChannels(scene),
FindPTypes(scene).c_str(),
GetAvgFacePerMesh(scene),
GetAvgVertsPerMesh(scene),
special_points[0][0], special_points[0][1], special_points[0][2],
special_points[1][0], special_points[1][1], special_points[1][2],
special_points[2][0], special_points[2][1], special_points[2][2]);
aiVector3D special_points[3]; if (silent) {
FindSpecialPoints(scene,special_points); printf("\n");
printf(format_string, return AssimpCmdError::Success;
mem.total, }
CountNodes(scene->mRootNode),
GetMaxDepth(scene->mRootNode),
scene->mNumMeshes,
scene->mNumAnimations,
scene->mNumTextures,
scene->mNumMaterials,
scene->mNumCameras,
scene->mNumLights,
CountVertices(scene),
CountFaces(scene),
CountBones(scene),
CountAnimChannels(scene),
FindPTypes(scene).c_str(),
GetAvgFacePerMesh(scene),
GetAvgVertsPerMesh(scene),
special_points[0][0],special_points[0][1],special_points[0][2],
special_points[1][0],special_points[1][1],special_points[1][2],
special_points[2][0],special_points[2][1],special_points[2][2]
)
;
if (silent) // meshes
{ if (scene->mNumMeshes) {
printf("\n"); printf("\nMeshes: (name) [vertices / bones / faces | primitive_types]\n");
return AssimpCmdError::Success; }
} for (unsigned int i = 0; i < scene->mNumMeshes; ++i) {
const aiMesh *mesh = scene->mMeshes[i];
printf(" %d (%s)", i, mesh->mName.C_Str());
printf(
": [%d / %d / %d |",
mesh->mNumVertices,
mesh->mNumBones,
mesh->mNumFaces);
const unsigned int ptypes = mesh->mPrimitiveTypes;
if (ptypes & aiPrimitiveType_POINT) {
printf(" point");
}
if (ptypes & aiPrimitiveType_LINE) {
printf(" line");
}
if (ptypes & aiPrimitiveType_TRIANGLE) {
printf(" triangle");
}
if (ptypes & aiPrimitiveType_POLYGON) {
printf(" polygon");
}
printf("]\n");
}
// meshes // materials
if (scene->mNumMeshes) { if (scene->mNumMaterials)
printf("\nMeshes: (name) [vertices / bones / faces | primitive_types]\n"); printf("\nNamed Materials:");
} for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
for (unsigned int i = 0; i < scene->mNumMeshes; ++i) { const aiMaterial *mat = scene->mMaterials[i];
const aiMesh* mesh = scene->mMeshes[i]; aiString name = mat->GetName();
printf(" %d (%s)", i, mesh->mName.C_Str()); printf("\n \'%s\'", name.data);
printf( if (mat->mNumProperties)
": [%d / %d / %d |", printf(" (prop) [index / bytes | texture semantic]");
mesh->mNumVertices, for (unsigned p = 0; p < mat->mNumProperties; p++) {
mesh->mNumBones, const aiMaterialProperty *prop = mat->mProperties[p];
mesh->mNumFaces const aiTextureType textype = static_cast<aiTextureType>(prop->mSemantic);
); printf("\n %d (%s): [%d / %d | %s]",
const unsigned int ptypes = mesh->mPrimitiveTypes; p,
if (ptypes & aiPrimitiveType_POINT) { printf(" point"); } prop->mKey.data,
if (ptypes & aiPrimitiveType_LINE) { printf(" line"); } prop->mIndex,
if (ptypes & aiPrimitiveType_TRIANGLE) { printf(" triangle"); } prop->mDataLength,
if (ptypes & aiPrimitiveType_POLYGON) { printf(" polygon"); } TextureTypeToString(textype));
printf("]\n"); }
} }
if (scene->mNumMaterials) {
printf("\n");
}
// materials // textures
unsigned int total=0; unsigned int total = 0;
for(unsigned int i = 0;i < scene->mNumMaterials; ++i) { for (unsigned int i = 0; i < scene->mNumMaterials; ++i) {
aiString name; aiString name;
if (AI_SUCCESS==aiGetMaterialString(scene->mMaterials[i],AI_MATKEY_NAME,&name)) { static const aiTextureType types[] = {
printf("%s\n \'%s\'",(total++?"":"\nNamed Materials:" ),name.data); aiTextureType_NONE,
} aiTextureType_DIFFUSE,
} aiTextureType_SPECULAR,
if(total) { aiTextureType_AMBIENT,
printf("\n"); aiTextureType_EMISSIVE,
} aiTextureType_HEIGHT,
aiTextureType_NORMALS,
aiTextureType_SHININESS,
aiTextureType_OPACITY,
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) {
for (unsigned int idx = 0; AI_SUCCESS == aiGetMaterialString(scene->mMaterials[i],
AI_MATKEY_TEXTURE(types[type], idx), &name);
++idx) {
printf("%s\n \'%s\'", (total++ ? "" : "\nTexture Refs:"), name.data);
}
}
}
if (total) {
printf("\n");
}
// textures // animations
total=0; total = 0;
for(unsigned int i = 0;i < scene->mNumMaterials; ++i) { for (unsigned int i = 0; i < scene->mNumAnimations; ++i) {
aiString name; if (scene->mAnimations[i]->mName.length) {
static const aiTextureType types[] = { printf("%s\n \'%s\'", (total++ ? "" : "\nNamed Animations:"), scene->mAnimations[i]->mName.data);
aiTextureType_NONE, }
aiTextureType_DIFFUSE, }
aiTextureType_SPECULAR, if (total) {
aiTextureType_AMBIENT, printf("\n");
aiTextureType_EMISSIVE, }
aiTextureType_HEIGHT,
aiTextureType_NORMALS,
aiTextureType_SHININESS,
aiTextureType_OPACITY,
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) {
for(unsigned int idx = 0;AI_SUCCESS==aiGetMaterialString(scene->mMaterials[i],
AI_MATKEY_TEXTURE(types[type],idx),&name); ++idx) {
printf("%s\n \'%s\'",(total++?"":"\nTexture Refs:" ),name.data);
}
}
}
if(total) {
printf("\n");
}
// animations // node hierarchy
total=0; printf("\nNode hierarchy:\n");
for(unsigned int i = 0;i < scene->mNumAnimations; ++i) { PrintHierarchy(scene->mRootNode, "", verbose);
if (scene->mAnimations[i]->mName.length) {
printf("%s\n \'%s\'",(total++?"":"\nNamed Animations:" ),scene->mAnimations[i]->mName.data);
}
}
if(total) {
printf("\n");
}
// node hierarchy printf("\n");
printf("\nNode hierarchy:\n"); return AssimpCmdError::Success;
PrintHierarchy(scene->mRootNode,"",verbose);
printf("\n");
return AssimpCmdError::Success;
} }