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

Merge branch 'master' into select_exporters

pull/2379/head
Kim Kulling 2019-03-17 23:44:35 +01:00 committed by GitHub
parent df6d257633 e899067f44
commit 22f4667932
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
14 changed files with 120 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
code/AssbinLoader.cpp
View File

@ -708,7 +708,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
unsigned char * uncompressedData = new unsigned char[ uncompressedSize ]; unsigned char * uncompressedData = new unsigned char[ uncompressedSize ];
int res = uncompress( uncompressedData, &uncompressedSize, compressedData, len ); int res = uncompress( uncompressedData, &uncompressedSize, compressedData, (uLong) len );
if(res != Z_OK) if(res != Z_OK)
{ {
delete [] uncompressedData; delete [] uncompressedData;

2
code/FBXConverter.cpp
View File

@ -964,7 +964,7 @@ namespace Assimp {
{ {
if (indices[i] < 0) epcount++; if (indices[i] < 0) epcount++;
} }
unsigned int pcount = indices.size(); unsigned int pcount = static_cast<unsigned int>( indices.size() );
unsigned int scount = out_mesh->mNumFaces = pcount - epcount; unsigned int scount = out_mesh->mNumFaces = pcount - epcount;
aiFace* fac = out_mesh->mFaces = new aiFace[scount](); aiFace* fac = out_mesh->mFaces = new aiFace[scount]();

20
code/FindInstancesProcess.cpp
View File

@ -178,30 +178,30 @@ void FindInstancesProcess::Execute( aiScene* pScene)
// use a constant epsilon for colors and UV coordinates // use a constant epsilon for colors and UV coordinates
static const float uvEpsilon = 10e-4f; static const float uvEpsilon = 10e-4f;
{ {
unsigned int i, end = orig->GetNumUVChannels(); unsigned int j, end = orig->GetNumUVChannels();
for(i = 0; i < end; ++i) { for(j = 0; j < end; ++j) {
if (!orig->mTextureCoords[i]) { if (!orig->mTextureCoords[j]) {
continue; continue;
} }
if(!CompareArrays(orig->mTextureCoords[i],inst->mTextureCoords[i],orig->mNumVertices,uvEpsilon)) { if(!CompareArrays(orig->mTextureCoords[j],inst->mTextureCoords[j],orig->mNumVertices,uvEpsilon)) {
break; break;
} }
} }
if (i != end) { if (j != end) {
continue; continue;
} }
} }
{ {
unsigned int i, end = orig->GetNumColorChannels(); unsigned int j, end = orig->GetNumColorChannels();
for(i = 0; i < end; ++i) { for(j = 0; j < end; ++j) {
if (!orig->mColors[i]) { if (!orig->mColors[j]) {
continue; continue;
} }
if(!CompareArrays(orig->mColors[i],inst->mColors[i],orig->mNumVertices,uvEpsilon)) { if(!CompareArrays(orig->mColors[j],inst->mColors[j],orig->mNumVertices,uvEpsilon)) {
break; break;
} }
} }
if (i != end) { if (j != end) {
continue; continue;
} }
} }

4
code/ImproveCacheLocality.cpp
View File

@ -112,7 +112,9 @@ void ImproveCacheLocalityProcess::Execute( aiScene* pScene)
} }
} }
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
ASSIMP_LOG_INFO_F("Cache relevant are ", numm, " meshes (", numf," faces). Average output ACMR is ", out / numf ); if (numf > 0) {
ASSIMP_LOG_INFO_F("Cache relevant are ", numm, " meshes (", numf, " faces). Average output ACMR is ", out / numf);
}
ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess finished. "); ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess finished. ");
} }
} }

10
code/MD3FileData.h
View File

@ -59,7 +59,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include <assimp/Compiler/pushpack1.h> #include <assimp/Compiler/pushpack1.h>
namespace Assimp { namespace Assimp {
namespace MD3 { namespace MD3 {
// to make it easier for us, we test the magic word against both "endianesses" // to make it easier for us, we test the magic word against both "endianesses"
@ -303,12 +303,12 @@ inline void Vec3NormalToLatLng( const aiVector3D& p_vIn, uint16_t& p_iOut )
b = int(57.2957795f * ( std::acos( p_vIn[2] ) ) * ( 255.0f / 360.0f )); b = int(57.2957795f * ( std::acos( p_vIn[2] ) ) * ( 255.0f / 360.0f ));
b &= 0xff; b &= 0xff;
((unsigned char*)&p_iOut)[0] = b; // longitude ((unsigned char*)&p_iOut)[0] = (unsigned char) b; // longitude
((unsigned char*)&p_iOut)[1] = a; // latitude ((unsigned char*)&p_iOut)[1] = (unsigned char) a; // latitude
} }
} }
} } // Namespace MD3
} } // Namespace Assimp
#endif // !! AI_MD3FILEHELPER_H_INC #endif // !! AI_MD3FILEHELPER_H_INC

52
code/MD3Loader.cpp
View File

@ -258,10 +258,10 @@ bool Q3Shader::LoadSkin(SkinData& fill, const std::string& pFile,IOSystem* io)
continue; continue;
fill.textures.push_back(SkinData::TextureEntry()); fill.textures.push_back(SkinData::TextureEntry());
SkinData::TextureEntry& s = fill.textures.back(); SkinData::TextureEntry &entry = fill.textures.back();
s.first = ss; entry.first = ss;
s.second = GetNextToken(buff); entry.second = GetNextToken(buff);
} }
return true; return true;
} }
@ -718,9 +718,7 @@ void MD3Importer::ConvertPath(const char* texture_name, const char* header_name,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file into the given scene structure. // Imports the given file into the given scene structure.
void MD3Importer::InternReadFile( const std::string& pFile, void MD3Importer::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler) {
aiScene* pScene, IOSystem* pIOHandler)
{
mFile = pFile; mFile = pFile;
mScene = pScene; mScene = pScene;
mIOHandler = pIOHandler; mIOHandler = pIOHandler;
@ -730,11 +728,13 @@ void MD3Importer::InternReadFile( const std::string& pFile,
std::string::size_type s = mFile.find_last_of("/\\"); std::string::size_type s = mFile.find_last_of("/\\");
if (s == std::string::npos) { if (s == std::string::npos) {
s = 0; s = 0;
} else {
++s;
}
filename = mFile.substr(s), path = mFile.substr(0, s);
for (std::string::iterator it = filename.begin(); it != filename.end(); ++it) {
*it = static_cast<char>( tolower(*it) );
} }
else ++s;
filename = mFile.substr(s), path = mFile.substr(0,s);
for( std::string::iterator it = filename .begin(); it != filename.end(); ++it)
*it = tolower( *it);
// Load multi-part model file, if necessary // Load multi-part model file, if necessary
if (configHandleMP) { if (configHandleMP) {
@ -905,15 +905,15 @@ void MD3Importer::InternReadFile( const std::string& pFile,
// Now search the current shader for a record with this name ( // Now search the current shader for a record with this name (
// excluding texture file extension) // excluding texture file extension)
if (!shaders.blocks.empty()) { if (!shaders.blocks.empty()) {
std::string::size_type sh = convertedPath.find_last_of('.');
if (sh == std::string::npos) {
sh = convertedPath.length();
}
std::string::size_type s = convertedPath.find_last_of('.'); const std::string without_ext = convertedPath.substr(0,sh);
if (s == std::string::npos)
s = convertedPath.length();
const std::string without_ext = convertedPath.substr(0,s);
std::list< Q3Shader::ShaderDataBlock >::const_iterator dit = std::find(shaders.blocks.begin(),shaders.blocks.end(),without_ext); std::list< Q3Shader::ShaderDataBlock >::const_iterator dit = std::find(shaders.blocks.begin(),shaders.blocks.end(),without_ext);
if (dit != shaders.blocks.end()) { if (dit != shaders.blocks.end()) {
// Hurra, wir haben einen. Tolle Sache. // We made it!
shader = &*dit; shader = &*dit;
ASSIMP_LOG_INFO("Found shader record for " +without_ext ); ASSIMP_LOG_INFO("Found shader record for " +without_ext );
} else { } else {
@ -945,8 +945,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
aiString szString; aiString szString;
if (convertedPath.length()) { if (convertedPath.length()) {
szString.Set(convertedPath); szString.Set(convertedPath);
} } else {
else {
ASSIMP_LOG_WARN("Texture file name has zero length. Using default name"); ASSIMP_LOG_WARN("Texture file name has zero length. Using default name");
szString.Set("dummy_texture.bmp"); szString.Set("dummy_texture.bmp");
} }
@ -955,8 +954,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
// prevent transparency by default // prevent transparency by default
int no_alpha = aiTextureFlags_IgnoreAlpha; int no_alpha = aiTextureFlags_IgnoreAlpha;
pcHelper->AddProperty(&no_alpha,1,AI_MATKEY_TEXFLAGS_DIFFUSE(0)); pcHelper->AddProperty(&no_alpha,1,AI_MATKEY_TEXFLAGS_DIFFUSE(0));
} } else {
else {
Q3Shader::ConvertShaderToMaterial(pcHelper,*shader); Q3Shader::ConvertShaderToMaterial(pcHelper,*shader);
} }
@ -1026,7 +1024,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
if (!shader || shader->cull == Q3Shader::CULL_CW) { if (!shader || shader->cull == Q3Shader::CULL_CW) {
std::swap(pcMesh->mFaces[i].mIndices[2],pcMesh->mFaces[i].mIndices[1]); std::swap(pcMesh->mFaces[i].mIndices[2],pcMesh->mFaces[i].mIndices[1]);
} }
pcTriangles++; ++pcTriangles;
} }
// Go to the next surface // Go to the next surface
@ -1042,8 +1040,9 @@ void MD3Importer::InternReadFile( const std::string& pFile,
} }
} }
if (!pScene->mNumMeshes) if (!pScene->mNumMeshes) {
throw DeadlyImportError( "MD3: File contains no valid mesh"); throw DeadlyImportError( "MD3: File contains no valid mesh");
}
pScene->mNumMaterials = iNumMaterials; pScene->mNumMaterials = iNumMaterials;
// Now we need to generate an empty node graph // Now we need to generate an empty node graph
@ -1057,7 +1056,6 @@ void MD3Importer::InternReadFile( const std::string& pFile,
pScene->mRootNode->mChildren = new aiNode*[pcHeader->NUM_TAGS]; pScene->mRootNode->mChildren = new aiNode*[pcHeader->NUM_TAGS];
for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) { for (unsigned int i = 0; i < pcHeader->NUM_TAGS; ++i, ++pcTags) {
aiNode* nd = pScene->mRootNode->mChildren[i] = new aiNode(); aiNode* nd = pScene->mRootNode->mChildren[i] = new aiNode();
nd->mName.Set((const char*)pcTags->NAME); nd->mName.Set((const char*)pcTags->NAME);
nd->mParent = pScene->mRootNode; nd->mParent = pScene->mRootNode;
@ -1085,8 +1083,12 @@ void MD3Importer::InternReadFile( const std::string& pFile,
pScene->mRootNode->mMeshes[i] = i; pScene->mRootNode->mMeshes[i] = i;
// Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system // Now rotate the whole scene 90 degrees around the x axis to convert to internal coordinate system
pScene->mRootNode->mTransformation = aiMatrix4x4(1.f,0.f,0.f,0.f, pScene->mRootNode->mTransformation = aiMatrix4x4(
0.f,0.f,1.f,0.f,0.f,-1.f,0.f,0.f,0.f,0.f,0.f,1.f); 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
);
} }
#endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER #endif // !! ASSIMP_BUILD_NO_MD3_IMPORTER

4
code/SMDLoader.cpp
View File

@ -486,7 +486,7 @@ void SMDImporter::CreateOutputAnimations(const std::string &pFile, IOSystem* pIO
if (bLoadAnimationList) { if (bLoadAnimationList) {
GetAnimationFileList(pFile, pIOHandler, animFileList); GetAnimationFileList(pFile, pIOHandler, animFileList);
} }
int animCount = animFileList.size() + 1; int animCount = static_cast<int>( animFileList.size() + 1u );
pScene->mNumAnimations = 1; pScene->mNumAnimations = 1;
pScene->mAnimations = new aiAnimation*[animCount]; pScene->mAnimations = new aiAnimation*[animCount];
memset(pScene->mAnimations, 0, sizeof(aiAnimation*)*animCount); memset(pScene->mAnimations, 0, sizeof(aiAnimation*)*animCount);
@ -510,7 +510,7 @@ void SMDImporter::CreateOutputAnimation(int index, const std::string &name) {
anim->mName.Set(name.c_str()); anim->mName.Set(name.c_str());
} }
anim->mDuration = dLengthOfAnim; anim->mDuration = dLengthOfAnim;
anim->mNumChannels = asBones.size(); anim->mNumChannels = static_cast<unsigned int>( asBones.size() );
anim->mTicksPerSecond = 25.0; // FIXME: is this correct? anim->mTicksPerSecond = 25.0; // FIXME: is this correct?
aiNodeAnim** pp = anim->mChannels = new aiNodeAnim*[anim->mNumChannels]; aiNodeAnim** pp = anim->mChannels = new aiNodeAnim*[anim->mNumChannels];

37
code/SortByPTypeProcess.cpp
View File

@ -228,36 +228,37 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
out->mNumVertices = (3 == real ? numPolyVerts : out->mNumFaces * (real+1)); out->mNumVertices = (3 == real ? numPolyVerts : out->mNumFaces * (real+1));
aiVector3D *vert(NULL), *nor(NULL), *tan(NULL), *bit(NULL); aiVector3D *vert(nullptr), *nor(nullptr), *tan(nullptr), *bit(nullptr);
aiVector3D *uv [AI_MAX_NUMBER_OF_TEXTURECOORDS]; aiVector3D *uv [AI_MAX_NUMBER_OF_TEXTURECOORDS];
aiColor4D *cols [AI_MAX_NUMBER_OF_COLOR_SETS]; aiColor4D *cols [AI_MAX_NUMBER_OF_COLOR_SETS];
if (mesh->mVertices) if (mesh->mVertices) {
vert = out->mVertices = new aiVector3D[out->mNumVertices]; vert = out->mVertices = new aiVector3D[out->mNumVertices];
}
if (mesh->mNormals) if (mesh->mNormals) {
nor = out->mNormals = new aiVector3D[out->mNumVertices]; nor = out->mNormals = new aiVector3D[out->mNumVertices];
}
if (mesh->mTangents) if (mesh->mTangents) {
{
tan = out->mTangents = new aiVector3D[out->mNumVertices]; tan = out->mTangents = new aiVector3D[out->mNumVertices];
bit = out->mBitangents = new aiVector3D[out->mNumVertices]; bit = out->mBitangents = new aiVector3D[out->mNumVertices];
} }
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS;++i) for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_TEXTURECOORDS;++j) {
{ uv[j] = nullptr;
if (mesh->mTextureCoords[i]) if (mesh->mTextureCoords[j]) {
uv[i] = out->mTextureCoords[i] = new aiVector3D[out->mNumVertices]; uv[j] = out->mTextureCoords[j] = new aiVector3D[out->mNumVertices];
else uv[i] = NULL; }
out->mNumUVComponents[i] = mesh->mNumUVComponents[i]; out->mNumUVComponents[j] = mesh->mNumUVComponents[j];
} }
for (unsigned int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS;++i) for (unsigned int j = 0; j < AI_MAX_NUMBER_OF_COLOR_SETS;++j) {
{ cols[j] = nullptr;
if (mesh->mColors[i]) if (mesh->mColors[j]) {
cols[i] = out->mColors[i] = new aiColor4D[out->mNumVertices]; cols[j] = out->mColors[j] = new aiColor4D[out->mNumVertices];
else cols[i] = NULL; }
} }
typedef std::vector< aiVertexWeight > TempBoneInfo; typedef std::vector< aiVertexWeight > TempBoneInfo;
@ -323,7 +324,7 @@ void SortByPTypeProcess::Execute( aiScene* pScene) {
in.mIndices[q] = outIdx++; in.mIndices[q] = outIdx++;
} }
in.mIndices = NULL; in.mIndices = nullptr;
++outFaces; ++outFaces;
} }
ai_assert(outFaces == out->mFaces + out->mNumFaces); ai_assert(outFaces == out->mFaces + out->mNumFaces);

40
code/StandardShapes.cpp
View File

@ -127,35 +127,35 @@ aiMesh* StandardShapes::MakeMesh(const std::vector<aiVector3D>& positions,
// Determine which kinds of primitives the mesh consists of // Determine which kinds of primitives the mesh consists of
aiMesh* out = new aiMesh(); aiMesh* out = new aiMesh();
switch (numIndices) switch (numIndices) {
{ case 1:
case 1: out->mPrimitiveTypes = aiPrimitiveType_POINT;
out->mPrimitiveTypes = aiPrimitiveType_POINT; break;
break; case 2:
case 2: out->mPrimitiveTypes = aiPrimitiveType_LINE;
out->mPrimitiveTypes = aiPrimitiveType_LINE; break;
break; case 3:
case 3: out->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
out->mPrimitiveTypes = aiPrimitiveType_TRIANGLE; break;
break; default:
default: out->mPrimitiveTypes = aiPrimitiveType_POLYGON;
out->mPrimitiveTypes = aiPrimitiveType_POLYGON; break;
break;
}; };
out->mNumFaces = (unsigned int)positions.size() / numIndices; out->mNumFaces = (unsigned int)positions.size() / numIndices;
out->mFaces = new aiFace[out->mNumFaces]; out->mFaces = new aiFace[out->mNumFaces];
for (unsigned int i = 0, a = 0; i < out->mNumFaces;++i) for (unsigned int i = 0, a = 0; i < out->mNumFaces;++i) {
{
aiFace& f = out->mFaces[i]; aiFace& f = out->mFaces[i];
f.mNumIndices = numIndices; f.mNumIndices = numIndices;
f.mIndices = new unsigned int[numIndices]; f.mIndices = new unsigned int[numIndices];
for (unsigned int i = 0; i < numIndices;++i,++a) for (unsigned int j = 0; i < numIndices; ++i, ++a) {
f.mIndices[i] = a; f.mIndices[j] = a;
}
} }
out->mNumVertices = (unsigned int)positions.size(); out->mNumVertices = (unsigned int)positions.size();
out->mVertices = new aiVector3D[out->mNumVertices]; out->mVertices = new aiVector3D[out->mNumVertices];
::memcpy(out->mVertices,&positions[0],out->mNumVertices*sizeof(aiVector3D)); ::memcpy(out->mVertices,&positions[0],out->mNumVertices*sizeof(aiVector3D));
return out; return out;
} }
@ -466,8 +466,8 @@ void StandardShapes::MakeCone(ai_real height,ai_real radius1,
// Need to flip face order? // Need to flip face order?
if ( SIZE_MAX != old ) { if ( SIZE_MAX != old ) {
for (size_t s = old; s < positions.size();s += 3) { for (size_t p = old; p < positions.size();p += 3) {
std::swap(positions[s],positions[s+1]); std::swap(positions[p],positions[p+1]);
} }
} }
} }

13
code/ValidateDataStructure.cpp
View File

@ -582,15 +582,16 @@ void ValidateDSProcess::SearchForInvalidTextures(const aiMaterial* pMaterial,
int iNumIndices = 0; int iNumIndices = 0;
int iIndex = -1; int iIndex = -1;
for (unsigned int i = 0; i < pMaterial->mNumProperties;++i) for (unsigned int i = 0; i < pMaterial->mNumProperties;++i) {
{ aiMaterialProperty* prop = pMaterial->mProperties[ i ];
aiMaterialProperty* prop = pMaterial->mProperties[i]; ai_assert(nullptr != prop);
if (!::strcmp(prop->mKey.data,"$tex.file") && prop->mSemantic == type) { if ( !::strcmp(prop->mKey.data,"$tex.file") && prop->mSemantic == static_cast<unsigned int>(type)) {
iIndex = std::max(iIndex, (int) prop->mIndex); iIndex = std::max(iIndex, (int) prop->mIndex);
++iNumIndices; ++iNumIndices;
if (aiPTI_String != prop->mType) if (aiPTI_String != prop->mType) {
ReportError("Material property %s is expected to be a string",prop->mKey.data); ReportError("Material property %s is expected to be a string", prop->mKey.data);
}
} }
} }
if (iIndex +1 != iNumIndices) { if (iIndex +1 != iNumIndices) {

4
test/unit/utSTLImportExport.cpp
View File

@ -152,10 +152,10 @@ TEST_F(utSTLImporterExporter, test_export_pointclouds) {
auto pMesh = scene.mMeshes[0]; auto pMesh = scene.mMeshes[0];
long numValidPoints = points.size(); size_t numValidPoints = points.size();
pMesh->mVertices = new aiVector3D[numValidPoints]; pMesh->mVertices = new aiVector3D[numValidPoints];
pMesh->mNumVertices = numValidPoints; pMesh->mNumVertices = static_cast<unsigned int>( numValidPoints );
int i = 0; int i = 0;
for (XYZ &p : points) { for (XYZ &p : points) {

40
tools/assimp_cmd/Info.cpp
View File

@ -51,27 +51,26 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#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 std::string TREE_BRANCH_ASCII = "|-"; const char *TREE_BRANCH_ASCII = "|-";
const std::string TREE_BRANCH_UTF8 = "\xe2\x94\x9c\xe2\x95\xb4"; const char *TREE_BRANCH_UTF8 = "\xe2\x94\x9c\xe2\x95\xb4";
const std::string TREE_STOP_ASCII = "'-"; const char *TREE_STOP_ASCII = "'-";
const std::string TREE_STOP_UTF8 = "\xe2\x94\x94\xe2\x95\xb4"; const char *TREE_STOP_UTF8 = "\xe2\x94\x94\xe2\x95\xb4";
const std::string TREE_CONTINUE_ASCII = "| "; const char *TREE_CONTINUE_ASCII = "| ";
const std::string TREE_CONTINUE_UTF8 = "\xe2\x94\x82 "; const char *TREE_CONTINUE_UTF8 = "\xe2\x94\x82 ";
// note: by default this is outputing utf-8 text. // note: by default this is using utf-8 text.
// this is well supported on pretty much any linux terminal. // this is well supported on pretty much any linux terminal.
// if this causes problems on some platform, // if this causes problems on some platform,
// put an #ifdef to use the ascii version for that platform. // put an #ifdef to use the ascii version for that platform.
const std::string TREE_BRANCH = TREE_BRANCH_UTF8; const char *TREE_BRANCH = TREE_BRANCH_UTF8;
const std::string TREE_STOP = TREE_STOP_UTF8; const char *TREE_STOP = TREE_STOP_UTF8;
const std::string TREE_CONTINUE = TREE_CONTINUE_UTF8; const char *TREE_CONTINUE = TREE_CONTINUE_UTF8;
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
unsigned int CountNodes(const aiNode* root) unsigned int CountNodes(const aiNode* root)
@ -280,14 +279,7 @@ void PrintHierarchy(
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
// 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) {
{
if (num < 1) {
printf("assimp info: Invalid number of arguments. "
"See \'assimp info --help\'\n");
return 1;
}
// --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);

13
tools/assimp_cmd/WriteDumb.cpp
View File

@ -276,9 +276,12 @@ inline uint32_t WriteBounds(const T* in, unsigned int size)
void ChangeInteger(uint32_t ofs,uint32_t n) void ChangeInteger(uint32_t ofs,uint32_t n)
{ {
const uint32_t cur = ftell(out); const uint32_t cur = ftell(out);
fseek(out,ofs,SEEK_SET); int retCode;
fwrite(&n,4,1,out); retCode = fseek(out, ofs, SEEK_SET);
fseek(out,cur,SEEK_SET); ai_assert(0 == retCode);
fwrite(&n, 4, 1, out);
retCode = fseek(out, cur, SEEK_SET);
ai_assert(0 == retCode);
} }
// ----------------------------------------------------------------------------------- // -----------------------------------------------------------------------------------
@ -1333,10 +1336,6 @@ int Assimp_Dump (const char* const* params, unsigned int num)
{ {
const char* fail = "assimp dump: Invalid number of arguments. " const char* fail = "assimp dump: Invalid number of arguments. "
"See \'assimp dump --help\'\r\n"; "See \'assimp dump --help\'\r\n";
if (num < 1) {
printf("%s", fail);
return 1;
}
// --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], "-?") ) {

2
tools/assimp_view/SceneAnimator.cpp
View File

@ -90,7 +90,7 @@ void SceneAnimator::SetAnimIndex( size_t pAnimIndex) {
delete mAnimEvaluator; mAnimEvaluator = nullptr; delete mAnimEvaluator; mAnimEvaluator = nullptr;
mNodesByName.clear(); mNodesByName.clear();
mCurrentAnimIndex = pAnimIndex; mCurrentAnimIndex = static_cast<int>( pAnimIndex );
// create the internal node tree. Do this even in case of invalid animation index // 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 // so that the transformation matrices are properly set up to mimic the current scene