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

Merge branch 'master' into fix_gltf2_export_componentType_error

pull/1925/head
wuxq 2018-04-29 11:29:43 +08:00 committed by GitHub
parent 814b56e5e2 410e9d4b3f
commit 7a7a706ebd
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
111 changed files with 936 additions and 1113 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
code/3DSConverter.cpp
View File

@ -120,7 +120,7 @@ void Discreet3DSImporter::ReplaceDefaultMaterial()
else if ( (*a) >= mScene->mMaterials.size()) else if ( (*a) >= mScene->mMaterials.size())
{ {
(*a) = idx; (*a) = idx;
DefaultLogger::get()->warn("Material index overflow in 3DS file. Using default material"); ASSIMP_LOG_WARN("Material index overflow in 3DS file. Using default material");
++cnt; ++cnt;
} }
} }
@ -132,7 +132,7 @@ void Discreet3DSImporter::ReplaceDefaultMaterial()
sMat.mDiffuse = aiColor3D(0.3f,0.3f,0.3f); sMat.mDiffuse = aiColor3D(0.3f,0.3f,0.3f);
mScene->mMaterials.push_back(sMat); mScene->mMaterials.push_back(sMat);
DefaultLogger::get()->info("3DS: Generating default material"); ASSIMP_LOG_INFO("3DS: Generating default material");
} }
} }
@ -147,12 +147,12 @@ void Discreet3DSImporter::CheckIndices(D3DS::Mesh& sMesh)
{ {
if ((*i).mIndices[a] >= sMesh.mPositions.size()) if ((*i).mIndices[a] >= sMesh.mPositions.size())
{ {
DefaultLogger::get()->warn("3DS: Vertex index overflow)"); 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())
{ {
DefaultLogger::get()->warn("3DS: Texture coordinate index overflow)"); 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;
} }
} }
@ -497,7 +497,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
pvCurrent->x *= -1.f; pvCurrent->x *= -1.f;
t2->x *= -1.f; t2->x *= -1.f;
} }
DefaultLogger::get()->info("3DS: Flipping mesh X-Axis"); ASSIMP_LOG_INFO("3DS: Flipping mesh X-Axis");
} }
// Handle pivot point // Handle pivot point
@ -573,11 +573,11 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
pcIn->aTargetPositionKeys.size() > 1) pcIn->aTargetPositionKeys.size() > 1)
{ {
aiAnimation* anim = pcSOut->mAnimations[0]; aiAnimation* anim = pcSOut->mAnimations[0];
ai_assert(NULL != anim); ai_assert(nullptr != anim);
if (pcIn->aCameraRollKeys.size() > 1) if (pcIn->aCameraRollKeys.size() > 1)
{ {
DefaultLogger::get()->debug("3DS: Converting camera roll track ..."); ASSIMP_LOG_DEBUG("3DS: Converting camera roll track ...");
// Camera roll keys - in fact they're just rotations // Camera roll keys - in fact they're just rotations
// around the camera's z axis. The angles are given // around the camera's z axis. The angles are given
@ -597,7 +597,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
#if 0 #if 0
if (pcIn->aTargetPositionKeys.size() > 1) if (pcIn->aTargetPositionKeys.size() > 1)
{ {
DefaultLogger::get()->debug("3DS: Converting target track ..."); ASSIMP_LOG_DEBUG("3DS: Converting target track ...");
// Camera or spot light - need to convert the separate // Camera or spot light - need to convert the separate
// target position channel to our representation // target position channel to our representation
@ -743,7 +743,7 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
// | | | | | // | | | | |
// MESH_0 MESH_1 MESH_2 ... MESH_N CAMERA_0 .... // MESH_0 MESH_1 MESH_2 ... MESH_N CAMERA_0 ....
// //
DefaultLogger::get()->warn("No hierarchy information has been found in the file. "); ASSIMP_LOG_WARN("No hierarchy information has been found in the file. ");
pcOut->mRootNode->mNumChildren = pcOut->mNumMeshes + 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());

2
code/3DSExporter.cpp
View File

@ -381,7 +381,7 @@ void Discreet3DSExporter::WriteTexture(const aiMaterial& mat, aiTextureType type
// TODO: handle embedded textures properly // TODO: handle embedded textures properly
if (path.data[0] == '*') { if (path.data[0] == '*') {
DefaultLogger::get()->error("Ignoring embedded texture for export: " + std::string(path.C_Str())); ASSIMP_LOG_ERROR("Ignoring embedded texture for export: " + std::string(path.C_Str()));
return; return;
} }

40
code/3DSLoader.cpp
View File

@ -258,8 +258,9 @@ void Discreet3DSImporter::ReadChunk(Discreet3DS::Chunk* pcOut)
if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSize()) if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSize())
throw DeadlyImportError("Chunk is too large"); throw DeadlyImportError("Chunk is too large");
if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSizeToLimit()) if (pcOut->Size - sizeof(Discreet3DS::Chunk) > stream->GetRemainingSizeToLimit()) {
DefaultLogger::get()->error("3DS: Chunk overflow"); ASSIMP_LOG_ERROR("3DS: Chunk overflow");
}
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -320,7 +321,7 @@ void Discreet3DSImporter::ParseEditorChunk()
// print the version number // print the version number
char buff[10]; char buff[10];
ASSIMP_itoa10(buff,stream->GetI2()); ASSIMP_itoa10(buff,stream->GetI2());
DefaultLogger::get()->info(std::string("3DS file format version: ") + buff); ASSIMP_LOG_INFO_F(std::string("3DS file format version: "), buff);
} }
break; break;
}; };
@ -361,7 +362,7 @@ void Discreet3DSImporter::ParseObjectChunk()
if (is_qnan(mClrAmbient.r)) if (is_qnan(mClrAmbient.r))
{ {
// We failed to read the ambient base color. // We failed to read the ambient base color.
DefaultLogger::get()->error("3DS: Failed to read ambient base color"); ASSIMP_LOG_ERROR("3DS: Failed to read ambient base color");
mClrAmbient.r = mClrAmbient.g = mClrAmbient.b = 0.0f; mClrAmbient.r = mClrAmbient.g = mClrAmbient.b = 0.0f;
} }
break; break;
@ -463,7 +464,7 @@ void Discreet3DSImporter::ParseChunk(const char* name, unsigned int num)
if (len < 1e-5) { if (len < 1e-5) {
// There are some files with lookat == position. Don't know why or whether it's ok or not. // There are some files with lookat == position. Don't know why or whether it's ok or not.
DefaultLogger::get()->error("3DS: Unable to read proper camera look-at vector"); 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);
} }
@ -629,9 +630,9 @@ void Discreet3DSImporter::SkipTCBInfo()
if (!flags) { if (!flags) {
// Currently we can't do anything with these values. They occur // Currently we can't do anything with these values. They occur
// quite rare, so it wouldn't be worth the effort implementing // quite rare, so it wouldn't be worth the effort implementing
// them. 3DS ist not really suitable for complex animations, // them. 3DS is not really suitable for complex animations,
// so full support is not required. // so full support is not required.
DefaultLogger::get()->warn("3DS: Skipping TCB animation info"); ASSIMP_LOG_WARN("3DS: Skipping TCB animation info");
} }
if (flags & Discreet3DS::KEY_USE_TENS) { if (flags & Discreet3DS::KEY_USE_TENS) {
@ -732,7 +733,6 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
// If object name is DUMMY, take this one instead // If object name is DUMMY, take this one instead
if (mCurrentNode->mName == "$$$DUMMY") { if (mCurrentNode->mName == "$$$DUMMY") {
//DefaultLogger::get()->warn("3DS: Skipping dummy object name for non-dummy object");
mCurrentNode->mName = std::string(sz); mCurrentNode->mName = std::string(sz);
break; break;
} }
@ -743,7 +743,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
if ( Discreet3DS::CHUNK_TRACKINFO != parent) if ( Discreet3DS::CHUNK_TRACKINFO != parent)
{ {
DefaultLogger::get()->warn("3DS: Skipping pivot subchunk for non usual object"); ASSIMP_LOG_WARN("3DS: Skipping pivot subchunk for non usual object");
break; break;
} }
@ -805,7 +805,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
{ {
// roll keys are accepted for cameras only // roll keys are accepted for cameras only
if (parent != Discreet3DS::CHUNK_TRACKCAMERA) { if (parent != Discreet3DS::CHUNK_TRACKCAMERA) {
DefaultLogger::get()->warn("3DS: Ignoring roll track for non-camera object"); ASSIMP_LOG_WARN("3DS: Ignoring roll track for non-camera object");
break; break;
} }
bool sortKeys = false; bool sortKeys = false;
@ -845,7 +845,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
// CAMERA FOV KEYFRAME // CAMERA FOV KEYFRAME
case Discreet3DS::CHUNK_TRACKFOV: case Discreet3DS::CHUNK_TRACKFOV:
{ {
DefaultLogger::get()->error("3DS: Skipping FOV animation track. " ASSIMP_LOG_ERROR("3DS: Skipping FOV animation track. "
"This is not supported"); "This is not supported");
} }
break; break;
@ -985,7 +985,7 @@ void Discreet3DSImporter::ParseFaceChunk()
} }
} }
if (0xcdcdcdcd == idx) { if (0xcdcdcdcd == idx) {
DefaultLogger::get()->error(std::string("3DS: Unknown material: ") + sz); ASSIMP_LOG_ERROR_F( "3DS: Unknown material: ", sz);
} }
// Now continue and read all material indices // Now continue and read all material indices
@ -995,7 +995,7 @@ void Discreet3DSImporter::ParseFaceChunk()
// check range // check range
if (fidx >= mMesh.mFaceMaterials.size()) { if (fidx >= mMesh.mFaceMaterials.size()) {
DefaultLogger::get()->error("3DS: Invalid face index in face material list"); ASSIMP_LOG_ERROR("3DS: Invalid face index in face material list");
} }
else mMesh.mFaceMaterials[fidx] = idx; else mMesh.mFaceMaterials[fidx] = idx;
}} }}
@ -1110,7 +1110,7 @@ void Discreet3DSImporter::ParseMaterialChunk()
if (!cnt) { if (!cnt) {
// This may not be, we use the default name instead // This may not be, we use the default name instead
DefaultLogger::get()->error("3DS: Empty material name"); ASSIMP_LOG_ERROR("3DS: Empty material name");
} }
else mScene->mMaterials.back().mName = std::string(sz,cnt); else mScene->mMaterials.back().mName = std::string(sz,cnt);
} }
@ -1123,7 +1123,7 @@ void Discreet3DSImporter::ParseMaterialChunk()
ParseColorChunk(pc); ParseColorChunk(pc);
if (is_qnan(pc->r)) { if (is_qnan(pc->r)) {
// color chunk is invalid. Simply ignore it // color chunk is invalid. Simply ignore it
DefaultLogger::get()->error("3DS: Unable to read DIFFUSE chunk"); ASSIMP_LOG_ERROR("3DS: Unable to read DIFFUSE chunk");
pc->r = pc->g = pc->b = 1.0f; pc->r = pc->g = pc->b = 1.0f;
}} }}
break; break;
@ -1135,7 +1135,7 @@ void Discreet3DSImporter::ParseMaterialChunk()
ParseColorChunk(pc); ParseColorChunk(pc);
if (is_qnan(pc->r)) { if (is_qnan(pc->r)) {
// color chunk is invalid. Simply ignore it // color chunk is invalid. Simply ignore it
DefaultLogger::get()->error("3DS: Unable to read SPECULAR chunk"); ASSIMP_LOG_ERROR("3DS: Unable to read SPECULAR chunk");
pc->r = pc->g = pc->b = 1.0f; pc->r = pc->g = pc->b = 1.0f;
}} }}
break; break;
@ -1147,7 +1147,7 @@ void Discreet3DSImporter::ParseMaterialChunk()
ParseColorChunk(pc); ParseColorChunk(pc);
if (is_qnan(pc->r)) { if (is_qnan(pc->r)) {
// color chunk is invalid. Simply ignore it // color chunk is invalid. Simply ignore it
DefaultLogger::get()->error("3DS: Unable to read AMBIENT chunk"); ASSIMP_LOG_ERROR("3DS: Unable to read AMBIENT chunk");
pc->r = pc->g = pc->b = 0.0f; pc->r = pc->g = pc->b = 0.0f;
}} }}
break; break;
@ -1159,7 +1159,7 @@ void Discreet3DSImporter::ParseMaterialChunk()
ParseColorChunk(pc); ParseColorChunk(pc);
if (is_qnan(pc->r)) { if (is_qnan(pc->r)) {
// color chunk is invalid. Simply ignore it // color chunk is invalid. Simply ignore it
DefaultLogger::get()->error("3DS: Unable to read EMISSIVE chunk"); ASSIMP_LOG_ERROR("3DS: Unable to read EMISSIVE chunk");
pc->r = pc->g = pc->b = 0.0f; pc->r = pc->g = pc->b = 0.0f;
}} }}
break; break;
@ -1293,7 +1293,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
pcOut->mScaleU = stream->GetF4(); pcOut->mScaleU = stream->GetF4();
if (0.0f == pcOut->mScaleU) if (0.0f == pcOut->mScaleU)
{ {
DefaultLogger::get()->warn("Texture coordinate scaling in the x direction is zero. Assuming 1."); ASSIMP_LOG_WARN("Texture coordinate scaling in the x direction is zero. Assuming 1.");
pcOut->mScaleU = 1.0f; pcOut->mScaleU = 1.0f;
} }
break; break;
@ -1302,7 +1302,7 @@ void Discreet3DSImporter::ParseTextureChunk(D3DS::Texture* pcOut)
pcOut->mScaleV = stream->GetF4(); pcOut->mScaleV = stream->GetF4();
if (0.0f == pcOut->mScaleV) if (0.0f == pcOut->mScaleV)
{ {
DefaultLogger::get()->warn("Texture coordinate scaling in the y direction is zero. Assuming 1."); ASSIMP_LOG_WARN("Texture coordinate scaling in the y direction is zero. Assuming 1.");
pcOut->mScaleV = 1.0f; pcOut->mScaleV = 1.0f;
} }
break; break;

38
code/ACLoader.cpp
View File

@ -85,7 +85,7 @@ static const aiImporterDesc desc = {
#define AI_AC_SKIP_TO_NEXT_TOKEN() \ #define AI_AC_SKIP_TO_NEXT_TOKEN() \
if (!SkipSpaces(&buffer)) \ if (!SkipSpaces(&buffer)) \
{ \ { \
DefaultLogger::get()->error("AC3D: Unexpected EOF/EOL"); \ ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL"); \
continue; \ continue; \
} }
@ -101,7 +101,7 @@ static const aiImporterDesc desc = {
{ \ { \
if (IsLineEnd( *buffer )) \ if (IsLineEnd( *buffer )) \
{ \ { \
DefaultLogger::get()->error("AC3D: Unexpected EOF/EOL in string"); \ ASSIMP_LOG_ERROR("AC3D: Unexpected EOF/EOL in string"); \
out = "ERROR"; \ out = "ERROR"; \
break; \ break; \
} \ } \
@ -120,7 +120,7 @@ static const aiImporterDesc desc = {
{ \ { \
if (strncmp(buffer,name,name_length) || !IsSpace(buffer[name_length])) \ if (strncmp(buffer,name,name_length) || !IsSpace(buffer[name_length])) \
{ \ { \
DefaultLogger::get()->error("AC3D: Unexpexted token. " name " was expected."); \ ASSIMP_LOG_ERROR("AC3D: Unexpexted token. " name " was expected."); \
continue; \ continue; \
} \ } \
buffer += name_length+1; \ buffer += name_length+1; \
@ -217,7 +217,7 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i",static_cast<unsigned int>(mLights->size())-1); light->mName.length = ::ai_snprintf(light->mName.data, MAXLEN, "ACLight_%i",static_cast<unsigned int>(mLights->size())-1);
obj.name = std::string( light->mName.data ); obj.name = std::string( light->mName.data );
DefaultLogger::get()->debug("AC3D: Light source encountered"); ASSIMP_LOG_DEBUG("AC3D: Light source encountered");
obj.type = Object::Light; obj.type = Object::Light;
} }
else if (!ASSIMP_strincmp(buffer,"group",5)) else if (!ASSIMP_strincmp(buffer,"group",5))
@ -307,12 +307,12 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
{ {
if (!GetNextLine()) if (!GetNextLine())
{ {
DefaultLogger::get()->error("AC3D: Unexpected EOF: not all vertices have been parsed yet"); ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: not all vertices have been parsed yet");
break; break;
} }
else if (!IsNumeric(*buffer)) else if (!IsNumeric(*buffer))
{ {
DefaultLogger::get()->error("AC3D: Unexpected token: not all vertices have been parsed yet"); ASSIMP_LOG_ERROR("AC3D: Unexpected token: not all vertices have been parsed yet");
--buffer; // make sure the line is processed a second time --buffer; // make sure the line is processed a second time
break; break;
} }
@ -338,8 +338,8 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
// example writes no surf chunks // example writes no surf chunks
if (!Q3DWorkAround) if (!Q3DWorkAround)
{ {
DefaultLogger::get()->warn("AC3D: SURF token was expected"); ASSIMP_LOG_WARN("AC3D: SURF token was expected");
DefaultLogger::get()->debug("Continuing with Quick3D Workaround enabled"); ASSIMP_LOG_DEBUG("Continuing with Quick3D Workaround enabled");
} }
--buffer; // make sure the line is processed a second time --buffer; // make sure the line is processed a second time
// break; --- see fix notes above // break; --- see fix notes above
@ -384,7 +384,7 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
{ {
if(!GetNextLine()) if(!GetNextLine())
{ {
DefaultLogger::get()->error("AC3D: Unexpected EOF: surface references are incomplete"); ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: surface references are incomplete");
break; break;
} }
surf.entries.push_back(Surface::SurfaceEntry()); surf.entries.push_back(Surface::SurfaceEntry());
@ -405,7 +405,7 @@ void AC3DImporter::LoadObjectSection(std::vector<Object>& objects)
} }
} }
} }
DefaultLogger::get()->error("AC3D: Unexpected EOF: \'kids\' line was expected"); ASSIMP_LOG_ERROR("AC3D: Unexpected EOF: \'kids\' line was expected");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -478,7 +478,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
therefore: if no surfaces are defined return point data only therefore: if no surfaces are defined return point data only
*/ */
DefaultLogger::get()->info("AC3D: No surfaces defined in object definition, " ASSIMP_LOG_INFO("AC3D: No surfaces defined in object definition, "
"a point list is returned"); "a point list is returned");
meshes.push_back(new aiMesh()); meshes.push_back(new aiMesh());
@ -519,12 +519,12 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
unsigned int idx = (*it).mat; unsigned int idx = (*it).mat;
if (idx >= needMat.size()) if (idx >= needMat.size())
{ {
DefaultLogger::get()->error("AC3D: material index is out of range"); ASSIMP_LOG_ERROR("AC3D: material index is out of range");
idx = 0; idx = 0;
} }
if ((*it).entries.empty()) if ((*it).entries.empty())
{ {
DefaultLogger::get()->warn("AC3D: surface her zero vertex references"); ASSIMP_LOG_WARN("AC3D: surface her zero vertex references");
} }
// validate all vertex indices to make sure we won't crash here // validate all vertex indices to make sure we won't crash here
@ -533,7 +533,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
{ {
if ((*it2).first >= object.vertices.size()) if ((*it2).first >= object.vertices.size())
{ {
DefaultLogger::get()->warn("AC3D: Invalid vertex reference"); ASSIMP_LOG_WARN("AC3D: Invalid vertex reference");
(*it2).first = 0; (*it2).first = 0;
} }
} }
@ -561,7 +561,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
if ((*it).flags & 0xf) if ((*it).flags & 0xf)
{ {
DefaultLogger::get()->warn("AC3D: The type flag of a surface is unknown"); ASSIMP_LOG_WARN("AC3D: The type flag of a surface is unknown");
(*it).flags &= ~(0xf); (*it).flags &= ~(0xf);
} }
@ -712,7 +712,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
if (object.subDiv) { if (object.subDiv) {
if (configEvalSubdivision) { if (configEvalSubdivision) {
std::unique_ptr<Subdivider> div(Subdivider::Create(Subdivider::CATMULL_CLARKE)); std::unique_ptr<Subdivider> div(Subdivider::Create(Subdivider::CATMULL_CLARKE));
DefaultLogger::get()->info("AC3D: Evaluating subdivision surface: "+object.name); ASSIMP_LOG_INFO("AC3D: Evaluating subdivision surface: "+object.name);
std::vector<aiMesh*> cpy(meshes.size()-oldm,NULL); std::vector<aiMesh*> cpy(meshes.size()-oldm,NULL);
div->Subdivide(&meshes[oldm],cpy.size(),&cpy.front(),object.subDiv,true); div->Subdivide(&meshes[oldm],cpy.size(),&cpy.front(),object.subDiv,true);
@ -721,7 +721,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
// previous meshes are deleted vy Subdivide(). // previous meshes are deleted vy Subdivide().
} }
else { else {
DefaultLogger::get()->info("AC3D: Letting the subdivision surface untouched due to my configuration: " ASSIMP_LOG_INFO("AC3D: Letting the subdivision surface untouched due to my configuration: "
+object.name); +object.name);
} }
} }
@ -813,7 +813,7 @@ void AC3DImporter::InternReadFile( const std::string& pFile,
unsigned int version = HexDigitToDecimal( buffer[4] ); unsigned int version = HexDigitToDecimal( buffer[4] );
char msg[3]; char msg[3];
ASSIMP_itoa10(msg,3,version); ASSIMP_itoa10(msg,3,version);
DefaultLogger::get()->info(std::string("AC3D file format version: ") + msg); ASSIMP_LOG_INFO_F("AC3D file format version: ", msg);
std::vector<Material> materials; std::vector<Material> materials;
materials.reserve(5); materials.reserve(5);
@ -857,7 +857,7 @@ void AC3DImporter::InternReadFile( const std::string& pFile,
} }
if (materials.empty()) if (materials.empty())
{ {
DefaultLogger::get()->warn("AC3D: No material has been found"); ASSIMP_LOG_WARN("AC3D: No material has been found");
materials.push_back(Material()); materials.push_back(Material());
} }

2
code/AMFImporter.cpp
View File

@ -230,7 +230,7 @@ casu_cres:
if(!skipped_before[sk_idx]) if(!skipped_before[sk_idx])
{ {
skipped_before[sk_idx] = true; skipped_before[sk_idx] = true;
LogWarning("Skipping node \"" + nn + "\" in " + pParentNodeName + "."); ASSIMP_LOG_WARN_F("Skipping node \"", nn, "\" in ", pParentNodeName, ".");
} }
} }

12
code/AMFImporter.hpp
View File

@ -358,18 +358,6 @@ private:
/************** Functions: LOG set *************/ /************** Functions: LOG set *************/
/***********************************************/ /***********************************************/
/// \fn void LogInfo(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->info()
void LogInfo(const std::string& pMessage) { DefaultLogger::get()->info(pMessage); }
/// \fn void LogWarning(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->warn()
void LogWarning(const std::string& pMessage) { DefaultLogger::get()->warn(pMessage); }
/// \fn void LogError(const std::string& pMessage)
/// Short variant for calling \ref DefaultLogger::get()->error()
void LogError(const std::string& pMessage) { DefaultLogger::get()->error(pMessage); }
/***********************************************/ /***********************************************/
/************** Functions: XML set *************/ /************** Functions: XML set *************/
/***********************************************/ /***********************************************/

16
code/ASELoader.cpp
View File

@ -200,7 +200,7 @@ void ASEImporter::InternReadFile( const std::string& pFile,
ConvertMeshes(*i,avOutMeshes); ConvertMeshes(*i,avOutMeshes);
} }
if (tookNormals) { if (tookNormals) {
DefaultLogger::get()->debug("ASE: Taking normals from the file. Use " ASSIMP_LOG_DEBUG("ASE: Taking normals from the file. Use "
"the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you " "the AI_CONFIG_IMPORT_ASE_RECONSTRUCT_NORMALS setting if you "
"experience problems"); "experience problems");
} }
@ -297,15 +297,15 @@ void ASEImporter::BuildAnimations(const std::vector<BaseNode*>& nodes)
// TODO: Implement Bezier & TCB support // TODO: Implement Bezier & TCB support
if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) { if ((*i)->mAnim.mPositionType != ASE::Animation::TRACK) {
DefaultLogger::get()->warn("ASE: Position controller uses Bezier/TCB keys. " 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) { if ((*i)->mAnim.mRotationType != ASE::Animation::TRACK) {
DefaultLogger::get()->warn("ASE: Rotation controller uses Bezier/TCB keys. " 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) {
DefaultLogger::get()->warn("ASE: Position controller uses Bezier/TCB keys. " ASSIMP_LOG_WARN("ASE: Position controller uses Bezier/TCB keys. "
"This is not supported."); "This is not supported.");
} }
@ -624,7 +624,7 @@ void ASEImporter::AddNodes (const std::vector<BaseNode*>& nodes,
node->mNumChildren++; node->mNumChildren++;
// What we did is so great, it is at least worth a debug message // What we did is so great, it is at least worth a debug message
DefaultLogger::get()->debug("ASE: Generating separate target node ("+snode->mName+")"); ASSIMP_LOG_DEBUG("ASE: Generating separate target node ("+snode->mName+")");
} }
} }
@ -947,7 +947,7 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
// validate the material index of the mesh // validate the material index of the mesh
if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) { if (mesh.iMaterialIndex >= mParser->m_vMaterials.size()) {
mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size()-1; mesh.iMaterialIndex = (unsigned int)mParser->m_vMaterials.size()-1;
DefaultLogger::get()->warn("Material index is out of range"); ASSIMP_LOG_WARN("Material index is out of range");
} }
// If the material the mesh is assigned to is consisting of submeshes, split it // If the material the mesh is assigned to is consisting of submeshes, split it
@ -957,11 +957,11 @@ void ASEImporter::ConvertMeshes(ASE::Mesh& mesh, std::vector<aiMesh*>& avOutMesh
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 submaterial // 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 // check range
if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) { if (mesh.mFaces[i].iMaterial >= vSubMaterials.size()) {
DefaultLogger::get()->warn("Submaterial index is out of range"); ASSIMP_LOG_WARN("Submaterial index is out of range");
// use the last material instead // use the last material instead
aiSplit[vSubMaterials.size()-1].push_back(i); aiSplit[vSubMaterials.size()-1].push_back(i);

26
code/ASEParser.cpp
View File

@ -151,7 +151,7 @@ void Parser::LogWarning(const char* szWarn)
#endif #endif
// output the warning to the logger ... // output the warning to the logger ...
DefaultLogger::get()->warn(szTemp); ASSIMP_LOG_WARN(szTemp);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -167,7 +167,7 @@ void Parser::LogInfo(const char* szWarn)
#endif #endif
// output the information to the logger ... // output the information to the logger ...
DefaultLogger::get()->info(szTemp); ASSIMP_LOG_INFO(szTemp);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -758,7 +758,7 @@ void Parser::ParseLV3MapBlock(Texture& map)
SkipToNextToken(); SkipToNextToken();
if (temp != "Bitmap" && temp != "Normal Bump") if (temp != "Bitmap" && temp != "Normal Bump")
{ {
DefaultLogger::get()->warn("ASE: Skipping unknown map type: " + temp); ASSIMP_LOG_WARN_F("ASE: Skipping unknown map type: ", temp);
parsePath = false; parsePath = false;
} }
continue; continue;
@ -773,7 +773,7 @@ void Parser::ParseLV3MapBlock(Texture& map)
{ {
// Files with 'None' as map name are produced by // Files with 'None' as map name are produced by
// an Maja to ASE exporter which name I forgot .. // an Maja to ASE exporter which name I forgot ..
DefaultLogger::get()->warn("ASE: Skipping invalid map entry"); ASSIMP_LOG_WARN("ASE: Skipping invalid map entry");
map.mMapName = ""; map.mMapName = "";
} }
@ -1072,7 +1072,7 @@ void Parser::ParseLV2AnimationBlock(ASE::BaseNode& mesh)
( mesh.mType != BaseNode::Light || ((ASE::Light&)mesh).mLightType != ASE::Light::TARGET)) ( mesh.mType != BaseNode::Light || ((ASE::Light&)mesh).mLightType != ASE::Light::TARGET))
{ {
DefaultLogger::get()->error("ASE: Found target animation channel " 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; anim = NULL;
} }
@ -1098,7 +1098,7 @@ void Parser::ParseLV2AnimationBlock(ASE::BaseNode& mesh)
if (!anim || anim == &mesh.mTargetAnim) if (!anim || anim == &mesh.mTargetAnim)
{ {
// Target animation channels may have no rotation channels // Target animation channels may have no rotation channels
DefaultLogger::get()->error("ASE: Ignoring scaling channel in target animation"); ASSIMP_LOG_ERROR("ASE: Ignoring scaling channel in target animation");
SkipSection(); SkipSection();
} }
else ParseLV3ScaleAnimationBlock(*anim); else ParseLV3ScaleAnimationBlock(*anim);
@ -1112,7 +1112,7 @@ void Parser::ParseLV2AnimationBlock(ASE::BaseNode& mesh)
if (!anim || anim == &mesh.mTargetAnim) if (!anim || anim == &mesh.mTargetAnim)
{ {
// Target animation channels may have no rotation channels // Target animation channels may have no rotation channels
DefaultLogger::get()->error("ASE: Ignoring rotation channel in target animation"); ASSIMP_LOG_ERROR("ASE: Ignoring rotation channel in target animation");
SkipSection(); SkipSection();
} }
else ParseLV3RotAnimationBlock(*anim); else ParseLV3RotAnimationBlock(*anim);
@ -1295,12 +1295,14 @@ void Parser::ParseLV2NodeTransformBlock(ASE::BaseNode& mesh)
{ {
mode = 2; mode = 2;
} }
else DefaultLogger::get()->error("ASE: Ignoring target transform, " else {
"this is no spot light or target camera"); ASSIMP_LOG_ERROR("ASE: Ignoring target transform, "
"this is no spot light or target camera");
}
} }
else else
{ {
DefaultLogger::get()->error("ASE: Unknown node transformation: " + temp); ASSIMP_LOG_ERROR("ASE: Unknown node transformation: " + temp);
// mode = 0 // mode = 0
} }
continue; continue;
@ -1916,7 +1918,7 @@ void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
else if (index == face.mIndices[2]) else if (index == face.mIndices[2])
index = 2; index = 2;
else { else {
DefaultLogger::get()->error("ASE: Invalid vertex index in MESH_VERTEXNORMAL section"); ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_VERTEXNORMAL section");
continue; continue;
} }
// We'll renormalize later // We'll renormalize later
@ -1928,7 +1930,7 @@ void Parser::ParseLV3MeshNormalListBlock(ASE::Mesh& sMesh)
ParseLV4MeshFloatTriple(&vNormal.x,faceIdx); ParseLV4MeshFloatTriple(&vNormal.x,faceIdx);
if (faceIdx >= sMesh.mFaces.size()) { if (faceIdx >= sMesh.mFaces.size()) {
DefaultLogger::get()->error("ASE: Invalid vertex index in MESH_FACENORMAL section"); ASSIMP_LOG_ERROR("ASE: Invalid vertex index in MESH_FACENORMAL section");
continue; continue;
} }

2
code/Assimp.cpp
View File

@ -146,7 +146,7 @@ private:
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void ReportSceneNotFoundError() { void ReportSceneNotFoundError() {
DefaultLogger::get()->error("Unable to find the Assimp::Importer for this aiScene. " ASSIMP_LOG_ERROR("Unable to find the Assimp::Importer for this aiScene. "
"The C-API does not accept scenes produced by the C++ API and vice versa"); "The C-API does not accept scenes produced by the C++ API and vice versa");
ai_assert(false); ai_assert(false);

2
code/B3DImporter.cpp
View File

@ -614,7 +614,7 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
char dmp[128]; char dmp[128];
ai_snprintf(dmp, 128, "B3D file format version: %i",version); ai_snprintf(dmp, 128, "B3D file format version: %i",version);
DefaultLogger::get()->info(dmp); ASSIMP_LOG_INFO(dmp);
} }
while( ChunkSize() ){ while( ChunkSize() ){

50
code/BaseImporter.cpp
View File

@ -64,23 +64,24 @@ using namespace Assimp;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Constructor to be privately used by Importer // Constructor to be privately used by Importer
BaseImporter::BaseImporter() BaseImporter::BaseImporter()
: m_progress() : m_progress() {
{
// nothing to do here // nothing to do here
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Destructor, private as well // Destructor, private as well
BaseImporter::~BaseImporter() BaseImporter::~BaseImporter() {
{
// nothing to do here // nothing to do here
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Imports the given file and returns the imported data. // Imports the given file and returns the imported data.
aiScene* BaseImporter::ReadFile(const Importer* pImp, const std::string& pFile, IOSystem* pIOHandler) aiScene* BaseImporter::ReadFile(const Importer* pImp, const std::string& pFile, IOSystem* pIOHandler) {
{
m_progress = pImp->GetProgressHandler(); m_progress = pImp->GetProgressHandler();
if (nullptr == m_progress) {
return nullptr;
}
ai_assert(m_progress); ai_assert(m_progress);
// Gather configuration properties for this run // Gather configuration properties for this run
@ -100,8 +101,8 @@ aiScene* BaseImporter::ReadFile(const Importer* pImp, const std::string& pFile,
} catch( const std::exception& err ) { } catch( const std::exception& err ) {
// extract error description // extract error description
m_ErrorText = err.what(); m_ErrorText = err.what();
DefaultLogger::get()->error(m_ErrorText); ASSIMP_LOG_ERROR(m_ErrorText);
return NULL; return nullptr;
} }
// return what we gathered from the import. // return what we gathered from the import.
@ -195,7 +196,7 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
// We got a match, either we don't care where it is, or it happens to // We got a match, either we don't care where it is, or it happens to
// be in the beginning of the file / line // be in the beginning of the file / line
if (!tokensSol || r == buffer || r[-1] == '\r' || r[-1] == '\n') { if (!tokensSol || r == buffer || r[-1] == '\r' || r[-1] == '\n') {
DefaultLogger::get()->debug(std::string("Found positive match for header keyword: ") + tokens[i]); ASSIMP_LOG_DEBUG_F( "Found positive match for header keyword: ", tokens[i] );
return true; return true;
} }
} }
@ -322,7 +323,7 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
// UTF 8 with BOM // UTF 8 with BOM
if((uint8_t)data[0] == 0xEF && (uint8_t)data[1] == 0xBB && (uint8_t)data[2] == 0xBF) { if((uint8_t)data[0] == 0xEF && (uint8_t)data[1] == 0xBB && (uint8_t)data[2] == 0xBF) {
DefaultLogger::get()->debug("Found UTF-8 BOM ..."); ASSIMP_LOG_DEBUG("Found UTF-8 BOM ...");
std::copy(data.begin()+3,data.end(),data.begin()); std::copy(data.begin()+3,data.end(),data.begin());
data.resize(data.size()-3); data.resize(data.size()-3);
@ -341,7 +342,7 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
// UTF 32 LE with BOM // UTF 32 LE with BOM
if(*((uint32_t*)&data.front()) == 0x0000FFFE) { if(*((uint32_t*)&data.front()) == 0x0000FFFE) {
DefaultLogger::get()->debug("Found UTF-32 BOM ..."); ASSIMP_LOG_DEBUG("Found UTF-32 BOM ...");
std::vector<char> output; std::vector<char> output;
int *ptr = (int*)&data[ 0 ]; int *ptr = (int*)&data[ 0 ];
@ -361,7 +362,7 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
// UTF 16 LE with BOM // UTF 16 LE with BOM
if(*((uint16_t*)&data.front()) == 0xFEFF) { if(*((uint16_t*)&data.front()) == 0xFEFF) {
DefaultLogger::get()->debug("Found UTF-16 BOM ..."); ASSIMP_LOG_DEBUG("Found UTF-16 BOM ...");
std::vector<unsigned char> output; std::vector<unsigned char> output;
utf8::utf16to8(data.begin(), data.end(), back_inserter(output)); utf8::utf16to8(data.begin(), data.end(), back_inserter(output));
@ -386,16 +387,14 @@ void BaseImporter::ConvertUTF8toISO8859_1(std::string& data)
data[j] = ((unsigned char) data[++i] + 0x40); data[j] = ((unsigned char) data[++i] + 0x40);
} else { } else {
std::stringstream stream; std::stringstream stream;
stream << "UTF8 code " << std::hex << data[i] << data[i + 1] << " can not be converted into ISA-8859-1."; stream << "UTF8 code " << std::hex << data[i] << data[i + 1] << " can not be converted into ISA-8859-1.";
ASSIMP_LOG_ERROR( stream.str() );
DefaultLogger::get()->error(stream.str());
data[j++] = data[i++]; data[j++] = data[i++];
data[j] = data[i]; data[j] = data[i];
} }
} else { } else {
DefaultLogger::get()->error("UTF8 code but only one character remaining"); ASSIMP_LOG_ERROR("UTF8 code but only one character remaining");
data[j] = data[i]; data[j] = data[i];
} }
@ -411,7 +410,7 @@ void BaseImporter::TextFileToBuffer(IOStream* stream,
std::vector<char>& data, std::vector<char>& data,
TextFileMode mode) TextFileMode mode)
{ {
ai_assert(NULL != stream); ai_assert(nullptr != stream);
const size_t fileSize = stream->FileSize(); const size_t fileSize = stream->FileSize();
if (mode == FORBID_EMPTY) { if (mode == FORBID_EMPTY) {
@ -472,14 +471,14 @@ struct Assimp::BatchData {
, pImporter( nullptr ) , pImporter( nullptr )
, next_id(0xffff) , next_id(0xffff)
, validate( validate ) { , validate( validate ) {
ai_assert( NULL != pIO ); ai_assert( nullptr != pIO );
pImporter = new Importer(); pImporter = new Importer();
pImporter->SetIOHandler( pIO ); pImporter->SetIOHandler( pIO );
} }
~BatchData() { ~BatchData() {
pImporter->SetIOHandler( NULL ); /* get pointer back into our possession */ pImporter->SetIOHandler( nullptr ); /* get pointer back into our possession */
delete pImporter; delete pImporter;
} }
@ -505,9 +504,8 @@ struct Assimp::BatchData {
typedef std::list<LoadRequest>::iterator LoadReqIt; typedef std::list<LoadRequest>::iterator LoadReqIt;
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
BatchLoader::BatchLoader(IOSystem* pIO, bool validate ) BatchLoader::BatchLoader(IOSystem* pIO, bool validate ) {
{ ai_assert(nullptr != pIO);
ai_assert(NULL != pIO);
m_data = new BatchData( pIO, validate ); m_data = new BatchData( pIO, validate );
} }
@ -573,7 +571,7 @@ aiScene* BatchLoader::GetImport( unsigned int which )
return sc; return sc;
} }
} }
return NULL; return nullptr;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -596,13 +594,13 @@ void BatchLoader::LoadAll()
if (!DefaultLogger::isNullLogger()) if (!DefaultLogger::isNullLogger())
{ {
DefaultLogger::get()->info("%%% BEGIN EXTERNAL FILE %%%"); ASSIMP_LOG_INFO("%%% BEGIN EXTERNAL FILE %%%");
DefaultLogger::get()->info("File: " + (*it).file); ASSIMP_LOG_INFO_F("File: ", (*it).file);
} }
m_data->pImporter->ReadFile((*it).file,pp); m_data->pImporter->ReadFile((*it).file,pp);
(*it).scene = m_data->pImporter->GetOrphanedScene(); (*it).scene = m_data->pImporter->GetOrphanedScene();
(*it).loaded = true; (*it).loaded = true;
DefaultLogger::get()->info("%%% END EXTERNAL FILE %%%"); ASSIMP_LOG_INFO("%%% END EXTERNAL FILE %%%");
} }
} }

2
code/BaseProcess.cpp
View File

@ -85,7 +85,7 @@ void BaseProcess::ExecuteOnScene( Importer* pImp)
// extract error description // extract error description
pImp->Pimpl()->mErrorString = err.what(); pImp->Pimpl()->mErrorString = err.what();
DefaultLogger::get()->error(pImp->Pimpl()->mErrorString); ASSIMP_LOG_ERROR(pImp->Pimpl()->mErrorString);
// and kill the partially imported data // and kill the partially imported data
delete pImp->Pimpl()->mScene; delete pImp->Pimpl()->mScene;

9
code/BlenderDNA.cpp
View File

@ -210,8 +210,7 @@ void DNAParser::Parse ()
s.size = offset; s.size = offset;
} }
DefaultLogger::get()->debug((format(),"BlenderDNA: Got ",dna.structures.size(), ASSIMP_LOG_DEBUG_F( "BlenderDNA: Got ", dna.structures.size()," structures with totally ",fields," fields");
" structures with totally ",fields," fields"));
#ifdef ASSIMP_BUILD_BLENDER_DEBUG #ifdef ASSIMP_BUILD_BLENDER_DEBUG
dna.DumpToFile(); dna.DumpToFile();
@ -233,7 +232,7 @@ void DNA :: DumpToFile()
std::ofstream f("dna.txt"); std::ofstream f("dna.txt");
if (f.fail()) { if (f.fail()) {
DefaultLogger::get()->error("Could not dump dna to dna.txt"); ASSIMP_LOG_ERROR("Could not dump dna to dna.txt");
return; return;
} }
f << "Field format: type name offset size" << "\n"; f << "Field format: type name offset size" << "\n";
@ -248,7 +247,7 @@ void DNA :: DumpToFile()
} }
f << std::flush; f << std::flush;
DefaultLogger::get()->info("BlenderDNA: Dumped dna to dna.txt"); ASSIMP_LOG_INFO("BlenderDNA: Dumped dna to dna.txt");
} }
#endif #endif
@ -367,7 +366,7 @@ void SectionParser :: Next()
} }
#ifdef ASSIMP_BUILD_BLENDER_DEBUG #ifdef ASSIMP_BUILD_BLENDER_DEBUG
DefaultLogger::get()->debug(current.id); ASSIMP_LOG_DEBUG(current.id);
#endif #endif
} }

2
code/BlenderDNA.h
View File

@ -381,7 +381,7 @@ template <> struct Structure :: _defaultInitializer<ErrorPolicy_Warn> {
template <typename T> template <typename T>
void operator ()(T& out, const char* reason = "<add reason>") { void operator ()(T& out, const char* reason = "<add reason>") {
DefaultLogger::get()->warn(reason); ASSIMP_LOG_WARN(reason);
// ... and let the show go on // ... and let the show go on
_defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out); _defaultInitializer<0 /*ErrorPolicy_Igno*/>()(out);

4
code/BlenderDNA.inl
View File

@ -468,9 +468,7 @@ template <> bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(std::shar
// this might happen if DNA::RegisterConverters hasn't been called so far // this might happen if DNA::RegisterConverters hasn't been called so far
// or if the target type is not contained in `our` DNA. // or if the target type is not contained in `our` DNA.
out.reset(); out.reset();
DefaultLogger::get()->warn((Formatter::format(), ASSIMP_LOG_WARN_F( "Failed to find a converter for the `",s.name,"` structure" );
"Failed to find a converter for the `",s.name,"` structure"
));
return false; return false;
} }

4
code/BlenderLoader.cpp
View File

@ -327,12 +327,12 @@ void BlenderImporter::ExtractScene(Scene& out, const FileDatabase& file)
ss.Convert(out,file); ss.Convert(out,file);
#ifndef ASSIMP_BUILD_BLENDER_NO_STATS #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
DefaultLogger::get()->info((format(), ASSIMP_LOG_INFO_F(
"(Stats) Fields read: " ,file.stats().fields_read, "(Stats) Fields read: " ,file.stats().fields_read,
", pointers resolved: " ,file.stats().pointers_resolved, ", pointers resolved: " ,file.stats().pointers_resolved,
", cache hits: " ,file.stats().cache_hits, ", cache hits: " ,file.stats().cache_hits,
", cached objects: " ,file.stats().cached_objects ", cached objects: " ,file.stats().cached_objects
)); );
#endif #endif
} }

2
code/BlenderModifier.h
View File

@ -86,7 +86,7 @@ public:
const Scene& /*in*/, const Scene& /*in*/,
const Object& /*orig_object*/ const Object& /*orig_object*/
) { ) {
DefaultLogger::get()->warn((Formatter::format("This modifier is not supported, skipping: "),orig_modifier.dna_type)); ASSIMP_LOG_INFO_F("This modifier is not supported, skipping: ",orig_modifier.dna_type );
return; return;
} }
}; };

100
code/COBLoader.cpp
View File

@ -150,7 +150,7 @@ void COBImporter::InternReadFile( const std::string& pFile,
ThrowException("Could not found magic id: `Caligari`"); ThrowException("Could not found magic id: `Caligari`");
} }
DefaultLogger::get()->info("File format tag: "+std::string(head+9,6)); ASSIMP_LOG_INFO_F("File format tag: ",std::string(head+9,6));
if (head[16]!='L') { if (head[16]!='L') {
ThrowException("File is big-endian, which is not supported"); ThrowException("File is big-endian, which is not supported");
} }
@ -303,7 +303,7 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
} }
std::unique_ptr<const Material> defmat; std::unique_ptr<const Material> defmat;
if(!min) { if(!min) {
DefaultLogger::get()->debug(format()<<"Could not resolve material index " ASSIMP_LOG_DEBUG(format()<<"Could not resolve material index "
<<reflist.first<<" - creating default material for this slot"); <<reflist.first<<" - creating default material for this slot");
defmat.reset(min=new Material()); defmat.reset(min=new Material());
@ -475,7 +475,7 @@ void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo
// we can recover if the chunk size was specified. // 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)) {
DefaultLogger::get()->error(error); ASSIMP_LOG_ERROR(error);
// (HACK) - our current position in the stream is the beginning of the // (HACK) - our current position in the stream is the beginning of the
// head line of the next chunk. That's fine, but the caller is going // head line of the next chunk. That's fine, but the caller is going
@ -487,46 +487,6 @@ void COBImporter::UnsupportedChunk_Ascii(LineSplitter& splitter, const ChunkInfo
else ThrowException(error); else ThrowException(error);
} }
// ------------------------------------------------------------------------------------------------
void COBImporter::LogWarn_Ascii(const LineSplitter& splitter, const format& message) {
LogWarn_Ascii(message << " [at line "<< splitter.get_index()<<"]");
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogError_Ascii(const LineSplitter& splitter, const format& message) {
LogError_Ascii(message << " [at line "<< splitter.get_index()<<"]");
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogInfo_Ascii(const LineSplitter& splitter, const format& message) {
LogInfo_Ascii(message << " [at line "<< splitter.get_index()<<"]");
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogDebug_Ascii(const LineSplitter& splitter, const format& message) {
LogDebug_Ascii(message << " [at line "<< splitter.get_index()<<"]");
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogWarn_Ascii(const Formatter::format& message) {
DefaultLogger::get()->warn(std::string("COB: ")+=message);
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogError_Ascii(const Formatter::format& message) {
DefaultLogger::get()->error(std::string("COB: ")+=message);
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogInfo_Ascii(const Formatter::format& message) {
DefaultLogger::get()->info(std::string("COB: ")+=message);
}
// ------------------------------------------------------------------------------------------------
void COBImporter::LogDebug_Ascii(const Formatter::format& message) {
DefaultLogger::get()->debug(std::string("COB: ")+=message);
}
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, const ChunkInfo& /*nfo*/) void COBImporter::ReadBasicNodeInfo_Ascii(Node& msh, LineSplitter& splitter, const ChunkInfo& /*nfo*/)
{ {
@ -576,8 +536,7 @@ void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const Chunk
++splitter; ++splitter;
if (!splitter.match_start("mat# ")) { if (!splitter.match_start("mat# ")) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `mat#` line in `Mat1` chunk ", nfo.id );
"Expected `mat#` line in `Mat1` chunk "<<nfo.id);
return; return;
} }
@ -589,8 +548,7 @@ void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const Chunk
++splitter; ++splitter;
if (!splitter.match_start("shader: ")) { if (!splitter.match_start("shader: ")) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `mat#` line in `Mat1` chunk ", nfo.id);
"Expected `mat#` line in `Mat1` chunk "<<nfo.id);
return; return;
} }
std::string shader = std::string(splitter[1]); std::string shader = std::string(splitter[1]);
@ -603,14 +561,12 @@ void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const Chunk
mat.shader = Material::PHONG; mat.shader = Material::PHONG;
} }
else if (shader != "flat") { else if (shader != "flat") {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Unknown value for `shader` in `Mat1` chunk ", nfo.id );
"Unknown value for `shader` in `Mat1` chunk "<<nfo.id);
} }
++splitter; ++splitter;
if (!splitter.match_start("rgb ")) { if (!splitter.match_start("rgb ")) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `rgb` line in `Mat1` chunk ", nfo.id);
"Expected `rgb` line in `Mat1` chunk "<<nfo.id);
} }
const char* rgb = splitter[1]; const char* rgb = splitter[1];
@ -618,8 +574,7 @@ void COBImporter::ReadMat1_Ascii(Scene& out, LineSplitter& splitter, const Chunk
++splitter; ++splitter;
if (!splitter.match_start("alpha ")) { if (!splitter.match_start("alpha ")) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `alpha` line in `Mat1` chunk ", nfo.id);
"Expected `alpha` line in `Mat1` chunk "<<nfo.id);
} }
const char* tokens[10]; const char* tokens[10];
@ -640,8 +595,7 @@ void COBImporter::ReadUnit_Ascii(Scene& out, LineSplitter& splitter, const Chunk
} }
++splitter; ++splitter;
if (!splitter.match_start("Units ")) { if (!splitter.match_start("Units ")) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `Units` line in `Unit` chunk ", nfo.id);
"Expected `Units` line in `Unit` chunk "<<nfo.id);
return; return;
} }
@ -652,13 +606,12 @@ void COBImporter::ReadUnit_Ascii(Scene& out, LineSplitter& splitter, const Chunk
const unsigned int t=strtoul10(splitter[1]); const unsigned int t=strtoul10(splitter[1]);
nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?( nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(
LogWarn_Ascii(splitter,format()<<t<<" is not a valid value for `Units` attribute in `Unit chunk` "<<nfo.id) ASSIMP_LOG_WARN_F(t, " is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id)
,1.f):units[t]; ,1.f):units[t];
return; return;
} }
} }
LogWarn_Ascii(splitter,format()<<"`Unit` chunk "<<nfo.id<<" is a child of " ASSIMP_LOG_WARN_F( "`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
<<nfo.parent_id<<" which does not exist");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -692,15 +645,13 @@ void COBImporter::ReadLght_Ascii(Scene& out, LineSplitter& splitter, const Chunk
msh.ltype = Light::SPOT; msh.ltype = Light::SPOT;
} }
else { else {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Unknown kind of light source in `Lght` chunk ", nfo.id, " : ", *splitter );
"Unknown kind of light source in `Lght` chunk "<<nfo.id<<" : "<<*splitter);
msh.ltype = Light::SPOT; msh.ltype = Light::SPOT;
} }
++splitter; ++splitter;
if (!splitter.match_start("color ")) { if (!splitter.match_start("color ")) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `color` line in `Lght` chunk ", nfo.id );
"Expected `color` line in `Lght` chunk "<<nfo.id);
} }
const char* rgb = splitter[1]; const char* rgb = splitter[1];
@ -708,16 +659,14 @@ void COBImporter::ReadLght_Ascii(Scene& out, LineSplitter& splitter, const Chunk
SkipSpaces(&rgb); SkipSpaces(&rgb);
if (strncmp(rgb,"cone angle",10)) { if (strncmp(rgb,"cone angle",10)) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `cone angle` entity in `color` line in `Lght` chunk ", nfo.id );
"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); msh.angle = fast_atof(&rgb);
SkipSpaces(&rgb); SkipSpaces(&rgb);
if (strncmp(rgb,"inner angle",11)) { if (strncmp(rgb,"inner angle",11)) {
LogWarn_Ascii(splitter,format()<< ASSIMP_LOG_WARN_F( "Expected `inner angle` entity in `color` line in `Lght` chunk ", nfo.id);
"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); msh.inner_angle = fast_atof(&rgb);
@ -828,7 +777,7 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
for(unsigned int cur = 0; cur < cnt && ++splitter ;++cur) { for(unsigned int cur = 0; cur < cnt && ++splitter ;++cur) {
if (splitter.match_start("Hole")) { if (splitter.match_start("Hole")) {
LogWarn_Ascii(splitter,"Skipping unsupported `Hole` line"); ASSIMP_LOG_WARN( "Skipping unsupported `Hole` line" );
continue; continue;
} }
@ -888,7 +837,7 @@ void COBImporter::ReadBitM_Ascii(Scene& /*out*/, LineSplitter& splitter, const C
const unsigned int head = strtoul10((++splitter)[1]); const unsigned int head = strtoul10((++splitter)[1]);
if (head != sizeof(Bitmap::BitmapHeader)) { if (head != sizeof(Bitmap::BitmapHeader)) {
LogWarn_Ascii(splitter,"Unexpected ThumbNailHdrSize, skipping this chunk"); ASSIMP_LOG_WARN("Unexpected ThumbNailHdrSize, skipping this chunk");
return; return;
} }
@ -935,7 +884,7 @@ void COBImporter::UnsupportedChunk_Binary( StreamReaderLE& reader, const ChunkIn
// we can recover if the chunk size was specified. // 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)) {
DefaultLogger::get()->error(error); ASSIMP_LOG_ERROR(error);
reader.IncPtr(nfo.size); reader.IncPtr(nfo.size);
} }
else ThrowException(error); else ThrowException(error);
@ -1142,7 +1091,7 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
mat.type = Material::METAL; mat.type = Material::METAL;
break; break;
default: default:
LogError_Ascii(format("Unrecognized shader type in `Mat1` chunk with id ")<<nfo.id); ASSIMP_LOG_ERROR_F( "Unrecognized shader type in `Mat1` chunk with id ", nfo.id );
mat.type = Material::FLAT; mat.type = Material::FLAT;
} }
@ -1157,7 +1106,7 @@ void COBImporter::ReadMat1_Binary(COB::Scene& out, StreamReaderLE& reader, const
mat.autofacet = Material::SMOOTH; mat.autofacet = Material::SMOOTH;
break; break;
default: default:
LogError_Ascii(format("Unrecognized faceting mode in `Mat1` chunk with id ")<<nfo.id); ASSIMP_LOG_ERROR_F( "Unrecognized faceting mode in `Mat1` chunk with id ", nfo.id );
mat.autofacet = Material::FACETED; mat.autofacet = Material::FACETED;
} }
mat.autofacet_angle = static_cast<float>(reader.GetI1()); mat.autofacet_angle = static_cast<float>(reader.GetI1());
@ -1289,16 +1238,13 @@ void COBImporter::ReadUnit_Binary(COB::Scene& out, StreamReaderLE& reader, const
if (nd->id == nfo.parent_id) { if (nd->id == nfo.parent_id) {
const unsigned int t=reader.GetI2(); const unsigned int t=reader.GetI2();
nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?( nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(
LogWarn_Ascii(format()<<t<<" is not a valid value for `Units` attribute in `Unit chunk` "<<nfo.id) ASSIMP_LOG_WARN_F(t," is not a valid value for `Units` attribute in `Unit chunk` ", nfo.id)
,1.f):units[t]; ,1.f):units[t];
return; return;
} }
} }
LogWarn_Ascii(format()<<"`Unit` chunk "<<nfo.id<<" is a child of " ASSIMP_LOG_WARN_F( "`Unit` chunk ", nfo.id, " is a child of ", nfo.parent_id, " which does not exist");
<<nfo.parent_id<<" which does not exist");
} }
#endif // ASSIMP_BUILD_NO_COB_IMPORTER
#endif

20
code/COBLoader.h
View File

@ -78,9 +78,6 @@ public:
COBImporter(); COBImporter();
~COBImporter(); ~COBImporter();
public:
// -------------------- // --------------------
bool CanRead( const std::string& pFile, IOSystem* pIOHandler, bool CanRead( const std::string& pFile, IOSystem* pIOHandler,
bool checkSig) const; bool checkSig) const;
@ -115,15 +112,11 @@ private:
* @param stream Stream to read from. */ * @param stream Stream to read from. */
void ReadBinaryFile(COB::Scene& out, StreamReaderLE* stream); void ReadBinaryFile(COB::Scene& out, StreamReaderLE* stream);
private:
// Conversion to Assimp output format // Conversion to Assimp output format
aiNode* BuildNodes(const COB::Node& root,const COB::Scene& scin,aiScene* fill); aiNode* BuildNodes(const COB::Node& root,const COB::Scene& scin,aiScene* fill);
private: private:
// ASCII file support // ASCII file support
void UnsupportedChunk_Ascii(LineSplitter& splitter, const COB::ChunkInfo& nfo, const char* name); void UnsupportedChunk_Ascii(LineSplitter& splitter, const COB::ChunkInfo& nfo, const char* name);
@ -142,19 +135,6 @@ private:
void ReadChan_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo); void ReadChan_Ascii(COB::Scene& out, LineSplitter& splitter, const COB::ChunkInfo& nfo);
// ASCII file logging stuff to add proper line numbers to messages
static void LogWarn_Ascii (const LineSplitter& splitter, const Formatter::format& message);
static void LogError_Ascii(const LineSplitter& splitter, const Formatter::format& message);
static void LogInfo_Ascii (const LineSplitter& splitter, const Formatter::format& message);
static void LogDebug_Ascii(const LineSplitter& splitter, const Formatter::format& message);
static void LogWarn_Ascii (const Formatter::format& message);
static void LogError_Ascii (const Formatter::format& message);
static void LogInfo_Ascii (const Formatter::format& message);
static void LogDebug_Ascii (const Formatter::format& message);
// Binary file support // Binary file support
void UnsupportedChunk_Binary(StreamReaderLE& reader, const COB::ChunkInfo& nfo, const char* name); void UnsupportedChunk_Binary(StreamReaderLE& reader, const COB::ChunkInfo& nfo, const char* name);

2
code/CSMLoader.cpp
View File

@ -233,7 +233,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
if (TokenMatchI(buffer, "DROPOUT", 7)) { if (TokenMatchI(buffer, "DROPOUT", 7)) {
// seems this is invalid marker data; at least the doc says it's possible // seems this is invalid marker data; at least the doc says it's possible
DefaultLogger::get()->warn("CSM: Encountered invalid marker data (DROPOUT)"); ASSIMP_LOG_WARN("CSM: Encountered invalid marker data (DROPOUT)");
} }
else { else {
aiVectorKey* sub = s->mPositionKeys + s->mNumPositionKeys; aiVectorKey* sub = s->mPositionKeys + s->mNumPositionKeys;

12
code/CalcTangentsProcess.cpp
View File

@ -95,7 +95,7 @@ void CalcTangentsProcess::Execute( aiScene* pScene)
{ {
ai_assert( NULL != pScene ); ai_assert( NULL != pScene );
DefaultLogger::get()->debug("CalcTangentsProcess begin"); ASSIMP_LOG_DEBUG("CalcTangentsProcess begin");
bool bHas = false; bool bHas = false;
for ( unsigned int a = 0; a < pScene->mNumMeshes; a++ ) { for ( unsigned int a = 0; a < pScene->mNumMeshes; a++ ) {
@ -103,9 +103,9 @@ void CalcTangentsProcess::Execute( aiScene* pScene)
} }
if ( bHas ) { if ( bHas ) {
DefaultLogger::get()->info("CalcTangentsProcess finished. Tangents have been calculated"); ASSIMP_LOG_INFO("CalcTangentsProcess finished. Tangents have been calculated");
} else { } else {
DefaultLogger::get()->debug("CalcTangentsProcess finished"); ASSIMP_LOG_DEBUG("CalcTangentsProcess finished");
} }
} }
@ -126,19 +126,19 @@ bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
// are undefined. // are undefined.
if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))
{ {
DefaultLogger::get()->info("Tangents are undefined for line and point meshes"); ASSIMP_LOG_INFO("Tangents are undefined for line and point meshes");
return false; return false;
} }
// what we can check, though, is if the mesh has normals and texture coordinates. That's a requirement // what we can check, though, is if the mesh has normals and texture coordinates. That's a requirement
if( pMesh->mNormals == NULL) if( pMesh->mNormals == NULL)
{ {
DefaultLogger::get()->error("Failed to compute tangents; need normals"); ASSIMP_LOG_ERROR("Failed to compute tangents; need normals");
return false; return false;
} }
if( configSourceUV >= AI_MAX_NUMBER_OF_TEXTURECOORDS || !pMesh->mTextureCoords[configSourceUV] ) if( configSourceUV >= AI_MAX_NUMBER_OF_TEXTURECOORDS || !pMesh->mTextureCoords[configSourceUV] )
{ {
DefaultLogger::get()->error((Formatter::format("Failed to compute tangents; need UV data in channel"),configSourceUV)); ASSIMP_LOG_ERROR((Formatter::format("Failed to compute tangents; need UV data in channel"),configSourceUV));
return false; return false;
} }

57
code/ColladaLoader.cpp
View File

@ -294,7 +294,7 @@ void ColladaLoader::ResolveNodeInstances( const ColladaParser& pParser, const Co
nd = FindNode(pParser.mRootNode, nodeInst.mNode); nd = FindNode(pParser.mRootNode, nodeInst.mNode);
} }
if (!nd) if (!nd)
DefaultLogger::get()->error("Collada: Unable to resolve reference to instanced node " + nodeInst.mNode); ASSIMP_LOG_ERROR_F("Collada: Unable to resolve reference to instanced node ", nodeInst.mNode);
else { else {
// attach this node to the list of children // attach this node to the list of children
@ -311,7 +311,7 @@ void ColladaLoader::ApplyVertexToEffectSemanticMapping(Collada::Sampler& sampler
std::map<std::string, Collada::InputSemanticMapEntry>::const_iterator it = table.mMap.find(sampler.mUVChannel); std::map<std::string, Collada::InputSemanticMapEntry>::const_iterator it = table.mMap.find(sampler.mUVChannel);
if (it != table.mMap.end()) { if (it != table.mMap.end()) {
if (it->second.mType != Collada::IT_Texcoord) if (it->second.mType != Collada::IT_Texcoord)
DefaultLogger::get()->error("Collada: Unexpected effect input mapping"); ASSIMP_LOG_ERROR("Collada: Unexpected effect input mapping");
sampler.mUVId = it->second.mSet; sampler.mUVId = it->second.mSet;
} }
@ -327,7 +327,7 @@ void ColladaLoader::BuildLightsForNode( const ColladaParser& pParser, const Coll
ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find( lid.mLight); ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find( lid.mLight);
if( srcLightIt == pParser.mLightLibrary.end()) if( srcLightIt == pParser.mLightLibrary.end())
{ {
DefaultLogger::get()->warn("Collada: Unable to find light for ID \"" + lid.mLight + "\". Skipping."); ASSIMP_LOG_WARN_F("Collada: Unable to find light for ID \"" , lid.mLight , "\". Skipping.");
continue; continue;
} }
const Collada::Light* srcLight = &srcLightIt->second; const Collada::Light* srcLight = &srcLightIt->second;
@ -395,14 +395,14 @@ void ColladaLoader::BuildCamerasForNode( const ColladaParser& pParser, const Col
ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find( cid.mCamera); ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find( cid.mCamera);
if( srcCameraIt == pParser.mCameraLibrary.end()) if( srcCameraIt == pParser.mCameraLibrary.end())
{ {
DefaultLogger::get()->warn("Collada: Unable to find camera for ID \"" + cid.mCamera + "\". Skipping."); ASSIMP_LOG_WARN_F("Collada: Unable to find camera for ID \"" , cid.mCamera , "\". Skipping.");
continue; continue;
} }
const Collada::Camera* srcCamera = &srcCameraIt->second; const Collada::Camera* srcCamera = &srcCameraIt->second;
// orthographic cameras not yet supported in Assimp // orthographic cameras not yet supported in Assimp
if (srcCamera->mOrtho) { if (srcCamera->mOrtho) {
DefaultLogger::get()->warn("Collada: Orthographic cameras are not supported."); ASSIMP_LOG_WARN("Collada: Orthographic cameras are not supported.");
} }
// now fill our ai data structure // now fill our ai data structure
@ -472,7 +472,7 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
if( !srcMesh) if( !srcMesh)
{ {
DefaultLogger::get()->warn( format() << "Collada: Unable to find geometry for ID \"" << mid.mMeshOrController << "\". Skipping." ); ASSIMP_LOG_WARN_F( "Collada: Unable to find geometry for ID \"", mid.mMeshOrController, "\". Skipping." );
continue; continue;
} }
} else } else
@ -501,7 +501,8 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
} }
else else
{ {
DefaultLogger::get()->warn( format() << "Collada: No material specified for subgroup <" << submesh.mMaterial << "> in geometry <" << mid.mMeshOrController << ">." ); ASSIMP_LOG_WARN_F( "Collada: No material specified for subgroup <", submesh.mMaterial, "> in geometry <",
mid.mMeshOrController, ">." );
if( !mid.mMaterials.empty() ) if( !mid.mMaterials.empty() )
meshMaterial = mid.mMaterials.begin()->second.mMatName; meshMaterial = mid.mMaterials.begin()->second.mMatName;
} }
@ -874,7 +875,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
if( bnode) if( bnode)
bone->mName.Set( FindNameForNode( bnode)); bone->mName.Set( FindNameForNode( bnode));
else else
DefaultLogger::get()->warn( format() << "ColladaLoader::CreateMesh(): could not find corresponding node for joint \"" << bone->mName.data << "\"." ); ASSIMP_LOG_WARN_F( "ColladaLoader::CreateMesh(): could not find corresponding node for joint \"", bone->mName.data, "\"." );
// and insert bone // and insert bone
dstMesh->mBones[boneCount++] = bone; dstMesh->mBones[boneCount++] = bone;
@ -1175,9 +1176,8 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
else if( subElement == "Z") else if( subElement == "Z")
entry.mSubElement = 2; entry.mSubElement = 2;
else else
DefaultLogger::get()->warn( format() << "Unknown anim subelement <" << subElement << ">. Ignoring" ); ASSIMP_LOG_WARN_F( "Unknown anim subelement <", subElement, ">. Ignoring" );
} else } else {
{
// no subelement following, transformId is remaining string // no subelement following, transformId is remaining string
entry.mTransformId = srcChannel.mTarget.substr( slashPos+1); entry.mTransformId = srcChannel.mTarget.substr( slashPos+1);
} }
@ -1406,7 +1406,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
anims.push_back( dstAnim); anims.push_back( dstAnim);
} else } else
{ {
DefaultLogger::get()->warn( "Collada loader: found empty animation channel, ignored. Please check your exporter."); ASSIMP_LOG_WARN( "Collada loader: found empty animation channel, ignored. Please check your exporter.");
} }
if( !entries.empty() && entries.front().mTimeAccessor->mCount > 0 ) if( !entries.empty() && entries.front().mTimeAccessor->mCount > 0 )
@ -1561,7 +1561,7 @@ void ColladaLoader::AddTexture ( aiMaterial& mat, const ColladaParser& pParser,
} }
} }
if (-1 == map) { if (-1 == map) {
DefaultLogger::get()->warn("Collada: unable to determine UV channel for texture"); ASSIMP_LOG_WARN("Collada: unable to determine UV channel for texture");
map = 0; map = 0;
} }
} }
@ -1598,7 +1598,7 @@ void ColladaLoader::FillMaterials( const ColladaParser& pParser, aiScene* /*pSce
break; break;
default: default:
DefaultLogger::get()->warn("Collada: Unrecognized shading mode, using gouraud shading"); ASSIMP_LOG_WARN("Collada: Unrecognized shading mode, using gouraud shading");
shadeMode = aiShadingMode_Gouraud; shadeMode = aiShadingMode_Gouraud;
break; break;
} }
@ -1657,9 +1657,10 @@ void ColladaLoader::FillMaterials( const ColladaParser& pParser, aiScene* /*pSce
} }
// add textures, if given // add textures, if given
if( !effect.mTexAmbient.mName.empty()) if (!effect.mTexAmbient.mName.empty()) {
/* It is merely a lightmap */ // It is merely a light-map
AddTexture( mat, pParser, effect, effect.mTexAmbient, aiTextureType_LIGHTMAP); AddTexture(mat, pParser, effect, effect.mTexAmbient, aiTextureType_LIGHTMAP);
}
if( !effect.mTexEmissive.mName.empty()) if( !effect.mTexEmissive.mName.empty())
AddTexture( mat, pParser, effect, effect.mTexEmissive, aiTextureType_EMISSIVE); AddTexture( mat, pParser, effect, effect.mTexEmissive, aiTextureType_EMISSIVE);
@ -1687,8 +1688,8 @@ void ColladaLoader::BuildMaterials( ColladaParser& pParser, aiScene* /*pScene*/)
{ {
newMats.reserve(pParser.mMaterialLibrary.size()); newMats.reserve(pParser.mMaterialLibrary.size());
for( ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin(); matIt != pParser.mMaterialLibrary.end(); ++matIt) for( ColladaParser::MaterialLibrary::const_iterator matIt = pParser.mMaterialLibrary.begin();
{ matIt != pParser.mMaterialLibrary.end(); ++matIt) {
const Collada::Material& material = matIt->second; const Collada::Material& material = matIt->second;
// a material is only a reference to an effect // a material is only a reference to an effect
ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find( material.mEffect); ColladaParser::EffectLibrary::iterator effIt = pParser.mEffectLibrary.find( material.mEffect);
@ -1752,11 +1753,7 @@ aiString ColladaLoader::FindFilenameForEffectTexture( const ColladaParser& pPars
ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find( name); ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find( name);
if( imIt == pParser.mImageLibrary.end()) if( imIt == pParser.mImageLibrary.end())
{ {
//missing texture should not stop the conversion ASSIMP_LOG_WARN_F("Collada: Unable to resolve effect texture entry \"", pName, "\", ended up at ID \"", name, "\".");
//throw DeadlyImportError( format() <<
// "Collada: Unable to resolve effect texture entry \"" << pName << "\", ended up at ID \"" << name << "\"." );
DefaultLogger::get()->warn("Collada: Unable to resolve effect texture entry \"" + pName + "\", ended up at ID \"" + name + "\".");
//set default texture file name //set default texture file name
result.Set(name + ".jpg"); result.Set(name + ".jpg");
@ -1775,7 +1772,7 @@ aiString ColladaLoader::FindFilenameForEffectTexture( const ColladaParser& pPars
// setup format hint // setup format hint
if (imIt->second.mEmbeddedFormat.length() > 3) { if (imIt->second.mEmbeddedFormat.length() > 3) {
DefaultLogger::get()->warn("Collada: texture format hint is too long, truncating to 3 characters"); ASSIMP_LOG_WARN("Collada: texture format hint is too long, truncating to 3 characters");
} }
strncpy(tex->achFormatHint,imIt->second.mEmbeddedFormat.c_str(),3); strncpy(tex->achFormatHint,imIt->second.mEmbeddedFormat.c_str(),3);
@ -1811,7 +1808,7 @@ void ColladaLoader::ConvertPath (aiString& ss)
{ {
// TODO: collada spec, p 22. Handle URI correctly. // TODO: collada spec, p 22. Handle URI correctly.
// For the moment we're just stripping the file:// away to make it work. // For the moment we're just stripping the file:// away to make it work.
// Windoes doesn't seem to be able to find stuff like // Windows doesn't seem to be able to find stuff like
// 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg' // 'file://..\LWO\LWO2\MappingModes\earthSpherical.jpg'
if (0 == strncmp(ss.data,"file://",7)) if (0 == strncmp(ss.data,"file://",7))
{ {
@ -1825,7 +1822,7 @@ void ColladaLoader::ConvertPath (aiString& ss)
if( ss.data[0] == '/' && isalpha( ss.data[1]) && ss.data[2] == ':' ) if( ss.data[0] == '/' && isalpha( ss.data[1]) && ss.data[2] == ':' )
{ {
ss.length--; ss.length--;
memmove( ss.data, ss.data+1, ss.length); ::memmove( ss.data, ss.data+1, ss.length);
ss.data[ss.length] = 0; ss.data[ss.length] = 0;
} }
@ -1875,9 +1872,9 @@ const std::string& ColladaLoader::ReadString( const Collada::Accessor& pAccessor
void ColladaLoader::CollectNodes( const aiNode* pNode, std::vector<const aiNode*>& poNodes) const void ColladaLoader::CollectNodes( const aiNode* pNode, std::vector<const aiNode*>& poNodes) const
{ {
poNodes.push_back( pNode); poNodes.push_back( pNode);
for (size_t a = 0; a < pNode->mNumChildren; ++a) {
for( size_t a = 0; a < pNode->mNumChildren; ++a) CollectNodes(pNode->mChildren[a], poNodes);
CollectNodes( pNode->mChildren[a], poNodes); }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

45
code/ColladaParser.cpp
View File

@ -152,22 +152,22 @@ void ColladaParser::ReadContents()
if (!::strncmp(version,"1.5",3)) { if (!::strncmp(version,"1.5",3)) {
mFormat = FV_1_5_n; mFormat = FV_1_5_n;
DefaultLogger::get()->debug("Collada schema version is 1.5.n"); ASSIMP_LOG_DEBUG("Collada schema version is 1.5.n");
} }
else if (!::strncmp(version,"1.4",3)) { else if (!::strncmp(version,"1.4",3)) {
mFormat = FV_1_4_n; mFormat = FV_1_4_n;
DefaultLogger::get()->debug("Collada schema version is 1.4.n"); ASSIMP_LOG_DEBUG("Collada schema version is 1.4.n");
} }
else if (!::strncmp(version,"1.3",3)) { else if (!::strncmp(version,"1.3",3)) {
mFormat = FV_1_3_n; mFormat = FV_1_3_n;
DefaultLogger::get()->debug("Collada schema version is 1.3.n"); ASSIMP_LOG_DEBUG("Collada schema version is 1.3.n");
} }
} }
ReadStructure(); ReadStructure();
} else } else
{ {
DefaultLogger::get()->debug( format() << "Ignoring global element <" << mReader->getNodeName() << ">." ); ASSIMP_LOG_DEBUG_F( "Ignoring global element <", mReader->getNodeName(), ">." );
SkipElement(); SkipElement();
} }
} else } else
@ -984,13 +984,13 @@ void ColladaParser::ReadImage( Collada::Image& pImage)
// they're not skipped. // they're not skipped.
int attrib = TestAttribute("array_index"); int attrib = TestAttribute("array_index");
if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) { if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
DefaultLogger::get()->warn("Collada: Ignoring texture array index"); ASSIMP_LOG_WARN("Collada: Ignoring texture array index");
continue; continue;
} }
attrib = TestAttribute("mip_index"); attrib = TestAttribute("mip_index");
if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) { if (attrib != -1 && mReader->getAttributeValueAsInt(attrib) > 0) {
DefaultLogger::get()->warn("Collada: Ignoring MIP map layer"); ASSIMP_LOG_WARN("Collada: Ignoring MIP map layer");
continue; continue;
} }
@ -1011,7 +1011,7 @@ void ColladaParser::ReadImage( Collada::Image& pImage)
// embedded image. get format // embedded image. get format
const int attrib = TestAttribute("format"); const int attrib = TestAttribute("format");
if (-1 == attrib) if (-1 == attrib)
DefaultLogger::get()->warn("Collada: Unknown image file format"); ASSIMP_LOG_WARN("Collada: Unknown image file format");
else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib); else pImage.mEmbeddedFormat = mReader->getAttributeValue(attrib);
const char* data = GetTextContent(); const char* data = GetTextContent();
@ -1590,7 +1590,7 @@ void ColladaParser::ReadSamplerProperties( Sampler& out )
out.mOp = aiTextureOp_Multiply; out.mOp = aiTextureOp_Multiply;
else { else {
DefaultLogger::get()->warn("Collada: Unsupported MAYA texture blend mode"); ASSIMP_LOG_WARN("Collada: Unsupported MAYA texture blend mode");
} }
TestClosing( "blend_mode"); TestClosing( "blend_mode");
} }
@ -2541,7 +2541,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
if( pInput.mIndex == 0) if( pInput.mIndex == 0)
pMesh->mPositions.push_back( aiVector3D( obj[0], obj[1], obj[2])); pMesh->mPositions.push_back( aiVector3D( obj[0], obj[1], obj[2]));
else else
DefaultLogger::get()->error("Collada: just one vertex position stream supported"); ASSIMP_LOG_ERROR("Collada: just one vertex position stream supported");
break; break;
case IT_Normal: case IT_Normal:
// pad to current vertex count if necessary // pad to current vertex count if necessary
@ -2552,7 +2552,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
if( pInput.mIndex == 0) if( pInput.mIndex == 0)
pMesh->mNormals.push_back( aiVector3D( obj[0], obj[1], obj[2])); pMesh->mNormals.push_back( aiVector3D( obj[0], obj[1], obj[2]));
else else
DefaultLogger::get()->error("Collada: just one vertex normal stream supported"); ASSIMP_LOG_ERROR("Collada: just one vertex normal stream supported");
break; break;
case IT_Tangent: case IT_Tangent:
// pad to current vertex count if necessary // pad to current vertex count if necessary
@ -2563,7 +2563,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
if( pInput.mIndex == 0) if( pInput.mIndex == 0)
pMesh->mTangents.push_back( aiVector3D( obj[0], obj[1], obj[2])); pMesh->mTangents.push_back( aiVector3D( obj[0], obj[1], obj[2]));
else else
DefaultLogger::get()->error("Collada: just one vertex tangent stream supported"); ASSIMP_LOG_ERROR("Collada: just one vertex tangent stream supported");
break; break;
case IT_Bitangent: case IT_Bitangent:
// pad to current vertex count if necessary // pad to current vertex count if necessary
@ -2574,7 +2574,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
if( pInput.mIndex == 0) if( pInput.mIndex == 0)
pMesh->mBitangents.push_back( aiVector3D( obj[0], obj[1], obj[2])); pMesh->mBitangents.push_back( aiVector3D( obj[0], obj[1], obj[2]));
else else
DefaultLogger::get()->error("Collada: just one vertex bitangent stream supported"); ASSIMP_LOG_ERROR("Collada: just one vertex bitangent stream supported");
break; break;
case IT_Texcoord: case IT_Texcoord:
// up to 4 texture coord sets are fine, ignore the others // up to 4 texture coord sets are fine, ignore the others
@ -2590,7 +2590,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
pMesh->mNumUVComponents[pInput.mIndex]=3; pMesh->mNumUVComponents[pInput.mIndex]=3;
} else } else
{ {
DefaultLogger::get()->error("Collada: too many texture coordinate sets. Skipping."); ASSIMP_LOG_ERROR("Collada: too many texture coordinate sets. Skipping.");
} }
break; break;
case IT_Color: case IT_Color:
@ -2610,7 +2610,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
pMesh->mColors[pInput.mIndex].push_back(result); pMesh->mColors[pInput.mIndex].push_back(result);
} else } else
{ {
DefaultLogger::get()->error("Collada: too many vertex color sets. Skipping."); ASSIMP_LOG_ERROR("Collada: too many vertex color sets. Skipping.");
} }
break; break;
@ -2739,7 +2739,7 @@ void ColladaParser::ReadSceneNode( Node* pNode)
{ {
const char* s = mReader->getAttributeValue(attrId); const char* s = mReader->getAttributeValue(attrId);
if (s[0] != '#') if (s[0] != '#')
DefaultLogger::get()->error("Collada: Unresolved reference format of camera"); ASSIMP_LOG_ERROR("Collada: Unresolved reference format of camera");
else else
pNode->mPrimaryCamera = s+1; pNode->mPrimaryCamera = s+1;
} }
@ -2752,7 +2752,7 @@ void ColladaParser::ReadSceneNode( Node* pNode)
{ {
const char* s = mReader->getAttributeValue(attrID); const char* s = mReader->getAttributeValue(attrID);
if (s[0] != '#') if (s[0] != '#')
DefaultLogger::get()->error("Collada: Unresolved reference format of node"); ASSIMP_LOG_ERROR("Collada: Unresolved reference format of node");
else else
{ {
pNode->mNodeInstances.push_back(NodeInstance()); pNode->mNodeInstances.push_back(NodeInstance());
@ -2770,7 +2770,7 @@ void ColladaParser::ReadSceneNode( Node* pNode)
// Reference to a light, name given in 'url' attribute // Reference to a light, name given in 'url' attribute
int attrID = TestAttribute("url"); int attrID = TestAttribute("url");
if (-1 == attrID) if (-1 == attrID)
DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_light> element"); ASSIMP_LOG_WARN("Collada: Expected url attribute in <instance_light> element");
else else
{ {
const char* url = mReader->getAttributeValue( attrID); const char* url = mReader->getAttributeValue( attrID);
@ -2786,7 +2786,7 @@ void ColladaParser::ReadSceneNode( Node* pNode)
// Reference to a camera, name given in 'url' attribute // Reference to a camera, name given in 'url' attribute
int attrID = TestAttribute("url"); int attrID = TestAttribute("url");
if (-1 == attrID) if (-1 == attrID)
DefaultLogger::get()->warn("Collada: Expected url attribute in <instance_camera> element"); ASSIMP_LOG_WARN("Collada: Expected url attribute in <instance_camera> element");
else else
{ {
const char* url = mReader->getAttributeValue( attrID); const char* url = mReader->getAttributeValue( attrID);
@ -2873,7 +2873,7 @@ void ColladaParser::ReadMaterialVertexInputBinding( Collada::SemanticMappingTabl
tbl.mMap[s] = vn; tbl.mMap[s] = vn;
} }
else if( IsElement( "bind")) { else if( IsElement( "bind")) {
DefaultLogger::get()->warn("Collada: Found unsupported <bind> element"); ASSIMP_LOG_WARN("Collada: Found unsupported <bind> element");
} }
} }
else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) { else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
@ -2992,10 +2992,9 @@ void ColladaParser::ReportWarning(const char* msg,...)
ai_assert(iLen > 0); ai_assert(iLen > 0);
va_end(args); va_end(args);
DefaultLogger::get()->warn("Validation warning: " + std::string(szBuffer,iLen)); ASSIMP_LOG_WARN_F("Validation warning: ", std::string(szBuffer,iLen));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Skips all data until the end node of the current element // Skips all data until the end node of the current element
void ColladaParser::SkipElement() void ColladaParser::SkipElement()
@ -3190,7 +3189,7 @@ aiMatrix4x4 ColladaParser::CalculateResultTransform( const std::vector<Transform
Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& semantic) Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& semantic)
{ {
if ( semantic.empty() ) { if ( semantic.empty() ) {
DefaultLogger::get()->warn( format() << "Vertex input type is empty." ); ASSIMP_LOG_WARN("Vertex input type is empty." );
return IT_Invalid; return IT_Invalid;
} }
@ -3209,7 +3208,7 @@ Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& semanti
else if( semantic == "TANGENT" || semantic == "TEXTANGENT") else if( semantic == "TANGENT" || semantic == "TEXTANGENT")
return IT_Tangent; return IT_Tangent;
DefaultLogger::get()->warn( format() << "Unknown vertex input type \"" << semantic << "\". Ignoring." ); ASSIMP_LOG_WARN_F( "Unknown vertex input type \"", semantic, "\". Ignoring." );
return IT_Invalid; return IT_Invalid;
} }

12
code/ComputeUVMappingProcess.cpp
View File

@ -99,7 +99,7 @@ inline unsigned int FindEmptyUVChannel (aiMesh* mesh)
for (unsigned int m = 0; m < AI_MAX_NUMBER_OF_TEXTURECOORDS;++m) for (unsigned int m = 0; m < AI_MAX_NUMBER_OF_TEXTURECOORDS;++m)
if (!mesh->mTextureCoords[m])return m; if (!mesh->mTextureCoords[m])return m;
DefaultLogger::get()->error("Unable to compute UV coordinates, no free UV slot found"); ASSIMP_LOG_ERROR("Unable to compute UV coordinates, no free UV slot found");
return UINT_MAX; return UINT_MAX;
} }
@ -384,13 +384,13 @@ void ComputeUVMappingProcess::ComputePlaneMapping(aiMesh* mesh,const aiVector3D&
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void ComputeUVMappingProcess::ComputeBoxMapping( aiMesh*, aiVector3D* ) void ComputeUVMappingProcess::ComputeBoxMapping( aiMesh*, aiVector3D* )
{ {
DefaultLogger::get()->error("Mapping type currently not implemented"); ASSIMP_LOG_ERROR("Mapping type currently not implemented");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void ComputeUVMappingProcess::Execute( aiScene* pScene) void ComputeUVMappingProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("GenUVCoordsProcess begin"); ASSIMP_LOG_DEBUG("GenUVCoordsProcess begin");
char buffer[1024]; char buffer[1024];
if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT)
@ -418,7 +418,7 @@ void ComputeUVMappingProcess::Execute( aiScene* pScene)
TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex, TextureTypeToString((aiTextureType)prop->mSemantic),prop->mIndex,
MappingTypeToString(mapping)); MappingTypeToString(mapping));
DefaultLogger::get()->info(buffer); ASSIMP_LOG_INFO(buffer);
} }
if (aiTextureMapping_OTHER == mapping) if (aiTextureMapping_OTHER == mapping)
@ -485,7 +485,7 @@ void ComputeUVMappingProcess::Execute( aiScene* pScene)
} }
if (m && idx != outIdx) if (m && idx != outIdx)
{ {
DefaultLogger::get()->warn("UV index mismatch. Not all meshes assigned to " ASSIMP_LOG_WARN("UV index mismatch. Not all meshes assigned to "
"this material have equal numbers of UV channels. The UV index stored in " "this material have equal numbers of UV channels. The UV index stored in "
"the material structure does therefore not apply for all meshes. "); "the material structure does therefore not apply for all meshes. ");
} }
@ -502,5 +502,5 @@ void ComputeUVMappingProcess::Execute( aiScene* pScene)
} }
} }
} }
DefaultLogger::get()->debug("GenUVCoordsProcess finished"); ASSIMP_LOG_DEBUG("GenUVCoordsProcess finished");
} }

18
code/ConvertToLHProcess.cpp
View File

@ -85,7 +85,7 @@ void MakeLeftHandedProcess::Execute( aiScene* pScene)
{ {
// Check for an existent root node to proceed // Check for an existent root node to proceed
ai_assert(pScene->mRootNode != NULL); ai_assert(pScene->mRootNode != NULL);
DefaultLogger::get()->debug("MakeLeftHandedProcess begin"); ASSIMP_LOG_DEBUG("MakeLeftHandedProcess begin");
// recursively convert all the nodes // recursively convert all the nodes
ProcessNode( pScene->mRootNode, aiMatrix4x4()); ProcessNode( pScene->mRootNode, aiMatrix4x4());
@ -110,7 +110,7 @@ void MakeLeftHandedProcess::Execute( aiScene* pScene)
ProcessAnimation( nodeAnim); ProcessAnimation( nodeAnim);
} }
} }
DefaultLogger::get()->debug("MakeLeftHandedProcess finished"); ASSIMP_LOG_DEBUG("MakeLeftHandedProcess finished");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -140,7 +140,7 @@ void MakeLeftHandedProcess::ProcessNode( aiNode* pNode, const aiMatrix4x4& pPare
// Converts a single mesh to left handed coordinates. // Converts a single mesh to left handed coordinates.
void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) { void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) {
if ( nullptr == pMesh ) { if ( nullptr == pMesh ) {
DefaultLogger::get()->error( "Nullptr to mesh found." ); ASSIMP_LOG_ERROR( "Nullptr to mesh found." );
return; return;
} }
// mirror positions, normals and stuff along the Z axis // mirror positions, normals and stuff along the Z axis
@ -180,7 +180,7 @@ void MakeLeftHandedProcess::ProcessMesh( aiMesh* pMesh) {
// Converts a single material to left handed coordinates. // Converts a single material to left handed coordinates.
void MakeLeftHandedProcess::ProcessMaterial( aiMaterial* _mat) { void MakeLeftHandedProcess::ProcessMaterial( aiMaterial* _mat) {
if ( nullptr == _mat ) { if ( nullptr == _mat ) {
DefaultLogger::get()->error( "Nullptr to aiMaterial found." ); ASSIMP_LOG_ERROR( "Nullptr to aiMaterial found." );
return; return;
} }
@ -245,13 +245,13 @@ bool FlipUVsProcess::IsActive( unsigned int pFlags) const
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void FlipUVsProcess::Execute( aiScene* pScene) void FlipUVsProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("FlipUVsProcess begin"); ASSIMP_LOG_DEBUG("FlipUVsProcess begin");
for (unsigned int i = 0; i < pScene->mNumMeshes;++i) for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
ProcessMesh(pScene->mMeshes[i]); ProcessMesh(pScene->mMeshes[i]);
for (unsigned int i = 0; i < pScene->mNumMaterials;++i) for (unsigned int i = 0; i < pScene->mNumMaterials;++i)
ProcessMaterial(pScene->mMaterials[i]); ProcessMaterial(pScene->mMaterials[i]);
DefaultLogger::get()->debug("FlipUVsProcess finished"); ASSIMP_LOG_DEBUG("FlipUVsProcess finished");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -262,7 +262,7 @@ void FlipUVsProcess::ProcessMaterial (aiMaterial* _mat)
for (unsigned int a = 0; a < mat->mNumProperties;++a) { for (unsigned int a = 0; a < mat->mNumProperties;++a) {
aiMaterialProperty* prop = mat->mProperties[a]; aiMaterialProperty* prop = mat->mProperties[a];
if( !prop ) { if( !prop ) {
DefaultLogger::get()->debug( "Property is null" ); ASSIMP_LOG_DEBUG( "Property is null" );
continue; continue;
} }
@ -319,10 +319,10 @@ bool FlipWindingOrderProcess::IsActive( unsigned int pFlags) const
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void FlipWindingOrderProcess::Execute( aiScene* pScene) void FlipWindingOrderProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("FlipWindingOrderProcess begin"); ASSIMP_LOG_DEBUG("FlipWindingOrderProcess begin");
for (unsigned int i = 0; i < pScene->mNumMeshes;++i) for (unsigned int i = 0; i < pScene->mNumMeshes;++i)
ProcessMesh(pScene->mMeshes[i]); ProcessMesh(pScene->mMeshes[i]);
DefaultLogger::get()->debug("FlipWindingOrderProcess finished"); ASSIMP_LOG_DEBUG("FlipWindingOrderProcess finished");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

2
code/D3MFImporter.cpp
View File

@ -396,7 +396,7 @@ private:
return false; return false;
} }
} }
DefaultLogger::get()->error("unexpected EOF, expected closing <" + closeTag + "> tag"); ASSIMP_LOG_ERROR("unexpected EOF, expected closing <" + closeTag + "> tag");
return false; return false;
} }

2
code/D3MFOpcPackage.cpp
View File

@ -465,7 +465,7 @@ D3MFOpcPackage::D3MFOpcPackage(IOSystem* pIOHandler, const std::string& rFile)
} }
} }
DefaultLogger::get()->debug(rootFile); ASSIMP_LOG_DEBUG(rootFile);
mRootStream = mZipArchive->Open(rootFile.c_str()); mRootStream = mZipArchive->Open(rootFile.c_str());
ai_assert( mRootStream != nullptr ); ai_assert( mRootStream != nullptr );

2
code/DXFHelper.h
View File

@ -146,7 +146,7 @@ public:
for(;splitter->length() && splitter->at(0) != '}'; splitter++, cnt++); for(;splitter->length() && splitter->at(0) != '}'; splitter++, cnt++);
splitter++; splitter++;
DefaultLogger::get()->debug((Formatter::format("DXF: skipped over control group ("),cnt," lines)")); ASSIMP_LOG_DEBUG((Formatter::format("DXF: skipped over control group ("),cnt," lines)"));
} }
} catch(std::logic_error&) { } catch(std::logic_error&) {
ai_assert(!splitter); ai_assert(!splitter);

89
code/DXFLoader.cpp
View File

@ -200,7 +200,7 @@ void DXFImporter::InternReadFile( const std::string& pFile,
// comments // comments
else if (reader.Is(999)) { else if (reader.Is(999)) {
DefaultLogger::get()->info("DXF Comment: " + reader.Value()); ASSIMP_LOG_INFO_F("DXF Comment: ", reader.Value());
} }
// don't read past the official EOF sign // don't read past the official EOF sign
@ -212,7 +212,7 @@ void DXFImporter::InternReadFile( const std::string& pFile,
++reader; ++reader;
} }
if (!eof) { if (!eof) {
DefaultLogger::get()->warn("DXF: EOF reached, but did not encounter DXF EOF marker"); ASSIMP_LOG_WARN("DXF: EOF reached, but did not encounter DXF EOF marker");
} }
ConvertMeshes(pScene,output); ConvertMeshes(pScene,output);
@ -229,7 +229,7 @@ void DXFImporter::InternReadFile( const std::string& pFile,
void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output) void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
{ {
// the process of resolving all the INSERT statements can grow the // the process of resolving all the INSERT statements can grow the
// polycount excessively, so log the original number. // poly-count excessively, so log the original number.
// XXX Option to import blocks as separate nodes? // XXX Option to import blocks as separate nodes?
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
@ -241,16 +241,14 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
} }
} }
DefaultLogger::get()->debug((Formatter::format("DXF: Unexpanded polycount is "), ASSIMP_LOG_DEBUG_F("DXF: Unexpanded polycount is ", icount, ", vertex count is ", vcount);
icount,", vertex count is ",vcount
));
} }
if (! output.blocks.size() ) { if (! output.blocks.size() ) {
throw DeadlyImportError("DXF: no data blocks loaded"); throw DeadlyImportError("DXF: no data blocks loaded");
} }
DXF::Block* entities = 0; DXF::Block* entities( nullptr );
// index blocks by name // index blocks by name
DXF::BlockMap blocks_by_name; DXF::BlockMap blocks_by_name;
@ -375,9 +373,7 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
// first check if the referenced blocks exists ... // first check if the referenced blocks exists ...
const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name); const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name);
if (it == blocks_by_name.end()) { if (it == blocks_by_name.end()) {
DefaultLogger::get()->error((Formatter::format("DXF: Failed to resolve block reference: "), ASSIMP_LOG_ERROR_F("DXF: Failed to resolve block reference: ", insert.name,"; skipping" );
insert.name,"; skipping"
));
continue; continue;
} }
@ -397,7 +393,7 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
// XXX rotation currently ignored - I didn't find an appropriate sample model. // XXX rotation currently ignored - I didn't find an appropriate sample model.
if (insert.angle != 0.f) { if (insert.angle != 0.f) {
DefaultLogger::get()->warn("DXF: BLOCK rotation not currently implemented"); ASSIMP_LOG_WARN("DXF: BLOCK rotation not currently implemented");
} }
for (aiVector3D& v : pl_out->positions) { for (aiVector3D& v : pl_out->positions) {
@ -410,7 +406,6 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/) void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
{ {
@ -437,7 +432,6 @@ void DXFImporter::GenerateMaterials(aiScene* pScene, DXF::FileData& /*output*/)
pScene->mMaterials[0] = pcMat; pScene->mMaterials[0] = pcMat;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/) void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/)
{ {
@ -448,9 +442,7 @@ void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/)
if (1 == pScene->mNumMeshes) { if (1 == pScene->mNumMeshes) {
pScene->mRootNode->mMeshes = new unsigned int[ pScene->mRootNode->mNumMeshes = 1 ]; pScene->mRootNode->mMeshes = new unsigned int[ pScene->mRootNode->mNumMeshes = 1 ];
pScene->mRootNode->mMeshes[0] = 0; pScene->mRootNode->mMeshes[0] = 0;
} } else {
else
{
pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren = pScene->mNumMeshes ]; pScene->mRootNode->mChildren = new aiNode*[ pScene->mRootNode->mNumChildren = pScene->mNumMeshes ];
for (unsigned int m = 0; m < pScene->mRootNode->mNumChildren;++m) { for (unsigned int m = 0; m < pScene->mRootNode->mNumChildren;++m) {
aiNode* p = pScene->mRootNode->mChildren[m] = new aiNode(); aiNode* p = pScene->mRootNode->mChildren[m] = new aiNode();
@ -465,22 +457,17 @@ void DXFImporter::GenerateHierarchy(aiScene* pScene, DXF::FileData& /*output*/)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::SkipSection(DXF::LineReader& reader) void DXFImporter::SkipSection(DXF::LineReader& reader) {
{
for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++); for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParseHeader(DXF::LineReader& reader, DXF::FileData& /*output*/) void DXFImporter::ParseHeader(DXF::LineReader& reader, DXF::FileData& ) {
{
for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++); for( ;!reader.End() && !reader.Is(0,"ENDSEC"); reader++);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output) {
{
while( !reader.End() && !reader.Is(0,"ENDSEC")) { while( !reader.End() && !reader.Is(0,"ENDSEC")) {
if (reader.Is(0,"BLOCK")) { if (reader.Is(0,"BLOCK")) {
ParseBlock(++reader,output); ParseBlock(++reader,output);
@ -489,15 +476,11 @@ void DXFImporter::ParseBlocks(DXF::LineReader& reader, DXF::FileData& output)
++reader; ++reader;
} }
DefaultLogger::get()->debug((Formatter::format("DXF: got "), ASSIMP_LOG_DEBUG_F("DXF: got ", output.blocks.size()," entries in BLOCKS" );
output.blocks.size()," entries in BLOCKS"
));
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output) {
{
// push a new block onto the stack. // push a new block onto the stack.
output.blocks.push_back( DXF::Block() ); output.blocks.push_back( DXF::Block() );
DXF::Block& block = output.blocks.back(); DXF::Block& block = output.blocks.back();
@ -527,7 +510,7 @@ void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output)
// XXX is this a valid case? // XXX is this a valid case?
if (reader.Is(0,"INSERT")) { if (reader.Is(0,"INSERT")) {
DefaultLogger::get()->warn("DXF: INSERT within a BLOCK not currently supported; skipping"); ASSIMP_LOG_WARN("DXF: INSERT within a BLOCK not currently supported; skipping");
for( ;!reader.End() && !reader.Is(0,"ENDBLK"); ++reader); for( ;!reader.End() && !reader.Is(0,"ENDBLK"); ++reader);
break; break;
} }
@ -541,7 +524,6 @@ void DXFImporter::ParseBlock(DXF::LineReader& reader, DXF::FileData& output)
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
{ {
@ -571,19 +553,16 @@ void DXFImporter::ParseEntities(DXF::LineReader& reader, DXF::FileData& output)
++reader; ++reader;
} }
DefaultLogger::get()->debug((Formatter::format("DXF: got "), ASSIMP_LOG_DEBUG_F( "DXF: got ", block.lines.size()," polylines and ", block.insertions.size(),
block.lines.size()," polylines and ", block.insertions.size() ," inserted blocks in ENTITIES" " inserted blocks in ENTITIES" );
));
} }
void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output)
{ {
output.blocks.back().insertions.push_back( DXF::InsertBlock() ); output.blocks.back().insertions.push_back( DXF::InsertBlock() );
DXF::InsertBlock& bl = output.blocks.back().insertions.back(); DXF::InsertBlock& bl = output.blocks.back().insertions.back();
while( !reader.End() && !reader.Is(0)) { while( !reader.End() && !reader.Is(0)) {
switch(reader.GroupCode()) switch(reader.GroupCode())
{ {
// name of referenced block // name of referenced block
@ -628,8 +607,7 @@ void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output)
#define DXF_POLYLINE_FLAG_POLYFACEMESH 0x40 #define DXF_POLYLINE_FLAG_POLYFACEMESH 0x40
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output) void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output) {
{
output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) ); output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
DXF::PolyLine& line = *output.blocks.back().lines.back(); DXF::PolyLine& line = *output.blocks.back().lines.back();
@ -682,16 +660,15 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
//} //}
if (vguess && line.positions.size() != vguess) { if (vguess && line.positions.size() != vguess) {
DefaultLogger::get()->warn((Formatter::format("DXF: unexpected vertex count in polymesh: "), ASSIMP_LOG_WARN_F("DXF: unexpected vertex count in polymesh: ",
line.positions.size(),", expected ", vguess line.positions.size(),", expected ", vguess );
));
} }
if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH ) { if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH ) {
if (line.positions.size() < 3 || line.indices.size() < 3) { if (line.positions.size() < 3 || line.indices.size() < 3) {
DefaultLogger::get()->warn("DXF: not enough vertices for polymesh; ignoring"); ASSIMP_LOG_WARN("DXF: not enough vertices for polymesh; ignoring");
output.blocks.back().lines.pop_back(); output.blocks.back().lines.pop_back();
return; return;
} }
// if these numbers are wrong, parsing might have gone wild. // if these numbers are wrong, parsing might have gone wild.
@ -699,13 +676,11 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
// to set the 71 and 72 fields, respectively, to valid values. // to set the 71 and 72 fields, respectively, to valid values.
// So just fire a warning. // So just fire a warning.
if (iguess && line.counts.size() != iguess) { if (iguess && line.counts.size() != iguess) {
DefaultLogger::get()->warn((Formatter::format("DXF: unexpected face count in polymesh: "), ASSIMP_LOG_WARN_F( "DXF: unexpected face count in polymesh: ", line.counts.size(),", expected ", iguess );
line.counts.size(),", expected ", iguess
));
} }
} }
else if (!line.indices.size() && !line.counts.size()) { else if (!line.indices.size() && !line.counts.size()) {
// a polyline - so there are no indices yet. // a poly-line - so there are no indices yet.
size_t guess = line.positions.size() + (line.flags & DXF_POLYLINE_FLAG_CLOSED ? 1 : 0); size_t guess = line.positions.size() + (line.flags & DXF_POLYLINE_FLAG_CLOSED ? 1 : 0);
line.indices.reserve(guess); line.indices.reserve(guess);
@ -747,10 +722,10 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
{ {
case 8: case 8:
// layer to which the vertex belongs to - assume that // layer to which the vertex belongs to - assume that
// this is always the layer the top-level polyline // this is always the layer the top-level poly-line
// entity resides on as well. // entity resides on as well.
if(reader.Value() != line.layer) { if(reader.Value() != line.layer) {
DefaultLogger::get()->warn("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set"); ASSIMP_LOG_WARN("DXF: expected vertex to be part of a poly-face but the 0x128 flag isn't set");
} }
break; break;
@ -769,7 +744,7 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
case 73: case 73:
case 74: case 74:
if (cnti == 4) { if (cnti == 4) {
DefaultLogger::get()->warn("DXF: more than 4 indices per face not supported; ignoring"); ASSIMP_LOG_WARN("DXF: more than 4 indices per face not supported; ignoring");
break; break;
} }
indices[cnti++] = reader.ValueAsUnsignedInt(); indices[cnti++] = reader.ValueAsUnsignedInt();
@ -785,7 +760,7 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
} }
if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH && !(flags & DXF_VERTEX_FLAG_PART_OF_POLYFACE)) { if (line.flags & DXF_POLYLINE_FLAG_POLYFACEMESH && !(flags & DXF_VERTEX_FLAG_PART_OF_POLYFACE)) {
DefaultLogger::get()->warn("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set"); ASSIMP_LOG_WARN("DXF: expected vertex to be part of a polyface but the 0x128 flag isn't set");
} }
if (cnti) { if (cnti) {
@ -793,14 +768,13 @@ void DXFImporter::ParsePolyLineVertex(DXF::LineReader& reader, DXF::PolyLine& li
for (unsigned int i = 0; i < cnti; ++i) { for (unsigned int i = 0; i < cnti; ++i) {
// IMPORTANT NOTE: POLYMESH indices are ONE-BASED // IMPORTANT NOTE: POLYMESH indices are ONE-BASED
if (indices[i] == 0) { if (indices[i] == 0) {
DefaultLogger::get()->warn("DXF: invalid vertex index, indices are one-based."); ASSIMP_LOG_WARN("DXF: invalid vertex index, indices are one-based.");
--line.counts.back(); --line.counts.back();
continue; continue;
} }
line.indices.push_back(indices[i]-1); line.indices.push_back(indices[i]-1);
} }
} } else {
else {
line.positions.push_back(out); line.positions.push_back(out);
line.colors.push_back(clr); line.colors.push_back(clr);
} }
@ -910,7 +884,7 @@ void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
// sanity checks to see if we got something meaningful // sanity checks to see if we got something meaningful
if ((b[1] && !b[0]) || !b[2] || !b[3]) { if ((b[1] && !b[0]) || !b[2] || !b[3]) {
DefaultLogger::get()->warn("DXF: unexpected vertex setup in 3DFACE/LINE/FACE entity; ignoring"); ASSIMP_LOG_WARN("DXF: unexpected vertex setup in 3DFACE/LINE/FACE entity; ignoring");
output.blocks.back().lines.pop_back(); output.blocks.back().lines.pop_back();
return; return;
} }
@ -926,4 +900,3 @@ void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
} }
#endif // !! ASSIMP_BUILD_NO_DXF_IMPORTER #endif // !! ASSIMP_BUILD_NO_DXF_IMPORTER

12
code/DeboneProcess.cpp
View File

@ -91,7 +91,7 @@ void DeboneProcess::SetupProperties(const Importer* pImp)
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void DeboneProcess::Execute( aiScene* pScene) void DeboneProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("DeboneProcess begin"); ASSIMP_LOG_DEBUG("DeboneProcess begin");
if(!pScene->mNumMeshes) { if(!pScene->mNumMeshes) {
return; return;
@ -148,9 +148,7 @@ void DeboneProcess::Execute( aiScene* pScene)
} }
if(!DefaultLogger::isNullLogger()) { if(!DefaultLogger::isNullLogger()) {
char buffer[1024]; ASSIMP_LOG_INFO_F("Removed %u bones. Input bones:", in - out, ". Output bones: ", out);
::ai_snprintf(buffer,1024,"Removed %u bones. Input bones: %u. Output bones: %u",in-out,in,out);
DefaultLogger::get()->info(buffer);
} }
// and destroy the source mesh. It should be completely contained inside the new submeshes // and destroy the source mesh. It should be completely contained inside the new submeshes
@ -173,7 +171,7 @@ void DeboneProcess::Execute( aiScene* pScene)
UpdateNode( pScene->mRootNode); UpdateNode( pScene->mRootNode);
} }
DefaultLogger::get()->debug("DeboneProcess end"); ASSIMP_LOG_DEBUG("DeboneProcess end");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -209,7 +207,7 @@ bool DeboneProcess::ConsiderMesh(const aiMesh* pMesh)
if(vertexBones[vid]!=cUnowned) { if(vertexBones[vid]!=cUnowned) {
if(vertexBones[vid]==i) //double entry if(vertexBones[vid]==i) //double entry
{ {
DefaultLogger::get()->warn("Encountered double entry in bone weights"); ASSIMP_LOG_WARN("Encountered double entry in bone weights");
} }
else //TODO: track attraction in order to break tie else //TODO: track attraction in order to break tie
{ {
@ -281,7 +279,7 @@ void DeboneProcess::SplitMesh( const aiMesh* pMesh, std::vector< std::pair< aiMe
if(vertexBones[vid]!=cUnowned) { if(vertexBones[vid]!=cUnowned) {
if(vertexBones[vid]==i) //double entry if(vertexBones[vid]==i) //double entry
{ {
//DefaultLogger::get()->warn("Encountered double entry in bone weights"); ASSIMP_LOG_WARN("Encountered double entry in bone weights");
} }
else //TODO: track attraction in order to break tie else //TODO: track attraction in order to break tie
{ {

6
code/DefaultIOSystem.cpp
View File

@ -170,7 +170,7 @@ inline static void MakeAbsolutePath (const char* in, char* _out)
if (!ret) { if (!ret) {
// preserve the input path, maybe someone else is able to fix // preserve the input path, maybe someone else is able to fix
// the path before it is accessed (e.g. our file system filter) // the path before it is accessed (e.g. our file system filter)
DefaultLogger::get()->warn("Invalid path: " + std::string(in)); ASSIMP_LOG_WARN_F("Invalid path: ", std::string(in));
strcpy(_out, in); strcpy(_out, in);
} }
@ -179,7 +179,7 @@ inline static void MakeAbsolutePath (const char* in, char* _out)
if (!ret) { if (!ret) {
// preserve the input path, maybe someone else is able to fix // preserve the input path, maybe someone else is able to fix
// the path before it is accessed (e.g. our file system filter) // the path before it is accessed (e.g. our file system filter)
DefaultLogger::get()->warn("Invalid path: " + std::string(in)); ASSIMP_LOG_WARN_F("Invalid path: ", std::string(in));
strcpy(_out, in); strcpy(_out, in);
} }
} }
@ -189,7 +189,7 @@ inline static void MakeAbsolutePath (const char* in, char* _out)
if(!ret) { if(!ret) {
// preserve the input path, maybe someone else is able to fix // preserve the input path, maybe someone else is able to fix
// the path before it is accessed (e.g. our file system filter) // the path before it is accessed (e.g. our file system filter)
DefaultLogger::get()->warn("Invalid path: "+std::string(in)); ASSIMP_LOG_WARN_F("Invalid path: ", std::string(in));
strcpy(_out,in); strcpy(_out,in);
} }
#endif #endif

8
code/EmbedTexturesProcess.cpp
View File

@ -93,9 +93,7 @@ void EmbedTexturesProcess::Execute(aiScene* pScene) {
} }
} }
char stringBuffer[128]; ASSIMP_LOG_INFO_F("EmbedTexturesProcess finished. Embedded ", embeddedTexturesCount, " textures." );
::ai_snprintf(stringBuffer, 128, "EmbedTexturesProcess finished. Embedded %u textures.", embeddedTexturesCount);
DefaultLogger::get()->info(stringBuffer);
} }
bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const { bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
@ -105,7 +103,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
// Test path directly // Test path directly
std::ifstream file(imagePath, std::ios::binary | std::ios::ate); std::ifstream file(imagePath, std::ios::binary | std::ios::ate);
if ((imageSize = file.tellg()) == std::streampos(-1)) { if ((imageSize = file.tellg()) == std::streampos(-1)) {
DefaultLogger::get()->warn("EmbedTexturesProcess: Cannot find image: " + imagePath + ". Will try to find it in root folder."); ASSIMP_LOG_WARN_F("EmbedTexturesProcess: Cannot find image: ", imagePath, ". Will try to find it in root folder.");
// Test path in root path // Test path in root path
imagePath = mRootPath + path; imagePath = mRootPath + path;
@ -115,7 +113,7 @@ bool EmbedTexturesProcess::addTexture(aiScene* pScene, std::string path) const {
imagePath = mRootPath + path.substr(path.find_last_of("\\/") + 1u); imagePath = mRootPath + path.substr(path.find_last_of("\\/") + 1u);
file.open(imagePath, std::ios::binary | std::ios::ate); file.open(imagePath, std::ios::binary | std::ios::ate);
if ((imageSize = file.tellg()) == std::streampos(-1)) { if ((imageSize = file.tellg()) == std::streampos(-1)) {
DefaultLogger::get()->error("EmbedTexturesProcess: Unable to embed texture: " + path + "."); ASSIMP_LOG_ERROR_F("EmbedTexturesProcess: Unable to embed texture: ", path, ".");
return false; return false;
} }
} }

2
code/Exporter.cpp
View File

@ -363,7 +363,7 @@ aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const c
} }
if (verbosify || (exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) { if (verbosify || (exp.mEnforcePP & aiProcess_JoinIdenticalVertices)) {
DefaultLogger::get()->debug("export: Scene data not in verbose format, applying MakeVerboseFormat step first"); ASSIMP_LOG_DEBUG("export: Scene data not in verbose format, applying MakeVerboseFormat step first");
MakeVerboseFormatProcess proc; MakeVerboseFormatProcess proc;
proc.Execute(scenecopy.get()); proc.Execute(scenecopy.get());

2
code/FBXDocument.cpp
View File

@ -214,7 +214,7 @@ const Object* LazyObject::Get(bool dieOnError)
// note: the error message is already formatted, so raw logging is ok // note: the error message is already formatted, so raw logging is ok
if(!DefaultLogger::isNullLogger()) { if(!DefaultLogger::isNullLogger()) {
DefaultLogger::get()->error(ex.what()); ASSIMP_LOG_ERROR(ex.what());
} }
return NULL; return NULL;
} }

4
code/FBXDocumentUtil.cpp
View File

@ -79,7 +79,7 @@ void DOMError(const std::string& message, const Element* element /*= NULL*/)
void DOMWarning(const std::string& message, const Token& token) void DOMWarning(const std::string& message, const Token& token)
{ {
if(DefaultLogger::get()) { if(DefaultLogger::get()) {
DefaultLogger::get()->warn(Util::AddTokenText("FBX-DOM",message,&token)); ASSIMP_LOG_WARN(Util::AddTokenText("FBX-DOM",message,&token));
} }
} }
@ -91,7 +91,7 @@ void DOMWarning(const std::string& message, const Element* element /*= NULL*/)
return; return;
} }
if(DefaultLogger::get()) { if(DefaultLogger::get()) {
DefaultLogger::get()->warn("FBX-DOM: " + message); ASSIMP_LOG_WARN("FBX-DOM: " + message);
} }
} }

14
code/FBXExporter.cpp
View File

@ -71,7 +71,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
// https://code.blender.org/2013/08/fbx-binary-file-format-specification/ // https://code.blender.org/2013/08/fbx-binary-file-format-specification/
// https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure // https://wiki.blender.org/index.php/User:Mont29/Foundation/FBX_File_Structure
const double DEG = 57.29577951308232087679815481; // degrees per radian const ai_real DEG = ai_real( 57.29577951308232087679815481 ); // degrees per radian
// some constants that we'll use for writing metadata // some constants that we'll use for writing metadata
namespace FBX { namespace FBX {
@ -980,9 +980,9 @@ aiMatrix4x4 get_world_transform(const aiNode* node, const aiScene* scene)
int64_t to_ktime(double ticks, const aiAnimation* anim) { int64_t to_ktime(double ticks, const aiAnimation* anim) {
if (anim->mTicksPerSecond <= 0) { if (anim->mTicksPerSecond <= 0) {
return ticks * FBX::SECOND; return static_cast<int64_t>(ticks) * FBX::SECOND;
} }
return (ticks / anim->mTicksPerSecond) * FBX::SECOND; return (static_cast<int64_t>(ticks) / static_cast<int64_t>(anim->mTicksPerSecond)) * FBX::SECOND;
} }
void FBXExporter::WriteObjects () void FBXExporter::WriteObjects ()
@ -1124,7 +1124,7 @@ void FBXExporter::WriteObjects ()
err << " has " << m->mNumUVComponents[uvi]; err << " has " << m->mNumUVComponents[uvi];
err << " components! Data will be preserved,"; err << " components! Data will be preserved,";
err << " but may be incorrectly interpreted on load."; err << " but may be incorrectly interpreted on load.";
DefaultLogger::get()->warn(err.str()); ASSIMP_LOG_WARN(err.str());
} }
FBX::Node uv("LayerElementUV", int32_t(uvi)); FBX::Node uv("LayerElementUV", int32_t(uvi));
uv.Begin(outstream, binary, indent); uv.Begin(outstream, binary, indent);
@ -1449,7 +1449,7 @@ void FBXExporter::WriteObjects ()
err << "Multilayer textures not supported (for now),"; err << "Multilayer textures not supported (for now),";
err << " skipping texture type " << j; err << " skipping texture type " << j;
err << " of material " << i; err << " of material " << i;
DefaultLogger::get()->warn(err.str()); ASSIMP_LOG_WARN(err.str());
} }
// get image path for this (single-image) texture // get image path for this (single-image) texture
@ -1484,7 +1484,7 @@ void FBXExporter::WriteObjects ()
err << "Not sure how to handle texture of type " << j; err << "Not sure how to handle texture of type " << j;
err << " on material " << i; err << " on material " << i;
err << ", skipping..."; err << ", skipping...";
DefaultLogger::get()->warn(err.str()); ASSIMP_LOG_WARN(err.str());
continue; continue;
} }
const std::string& prop_name = elem2->second; const std::string& prop_name = elem2->second;
@ -2440,7 +2440,7 @@ void FBXExporter::WriteAnimationCurve(
// TODO: keyattr flags and data (STUB for now) // TODO: keyattr flags and data (STUB for now)
n.AddChild("KeyAttrFlags", std::vector<int32_t>{0}); n.AddChild("KeyAttrFlags", std::vector<int32_t>{0});
n.AddChild("KeyAttrDataFloat", std::vector<float>{0,0,0,0}); n.AddChild("KeyAttrDataFloat", std::vector<float>{0,0,0,0});
ai_assert(times.size() <= std::numeric_limits<int32_t>::max()); ai_assert(static_cast<int32_t>(times.size()) <= std::numeric_limits<int32_t>::max());
n.AddChild( n.AddChild(
"KeyAttrRefCount", "KeyAttrRefCount",
std::vector<int32_t>{static_cast<int32_t>(times.size())} std::vector<int32_t>{static_cast<int32_t>(times.size())}

13
code/FindDegenerates.cpp
View File

@ -85,11 +85,11 @@ void FindDegeneratesProcess::SetupProperties(const Importer* pImp) {
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void FindDegeneratesProcess::Execute( aiScene* pScene) { void FindDegeneratesProcess::Execute( aiScene* pScene) {
DefaultLogger::get()->debug("FindDegeneratesProcess begin"); ASSIMP_LOG_DEBUG("FindDegeneratesProcess begin");
for (unsigned int i = 0; i < pScene->mNumMeshes;++i){ for (unsigned int i = 0; i < pScene->mNumMeshes;++i){
ExecuteOnMesh( pScene->mMeshes[ i ] ); ExecuteOnMesh( pScene->mMeshes[ i ] );
} }
DefaultLogger::get()->debug("FindDegeneratesProcess finished"); ASSIMP_LOG_DEBUG("FindDegeneratesProcess finished");
} }
static ai_real heron( ai_real a, ai_real b, ai_real c ) { static ai_real heron( ai_real a, ai_real b, ai_real c ) {
@ -242,7 +242,7 @@ evil_jump_outside:
if (!mesh->mNumFaces) { if (!mesh->mNumFaces) {
// WTF!? // WTF!?
// OK ... for completeness and because I'm not yet tired, // OK ... for completeness and because I'm not yet tired,
// let's write code that willl hopefully never be called // let's write code that will hopefully never be called
// (famous last words) // (famous last words)
// OK ... bad idea. // OK ... bad idea.
@ -250,10 +250,7 @@ evil_jump_outside:
} }
} }
if (deg && !DefaultLogger::isNullLogger()) if (deg && !DefaultLogger::isNullLogger()) {
{ ASSIMP_LOG_WARN_F( "Found ", deg, " degenerated primitives");
char s[64];
ASSIMP_itoa10(s,deg);
DefaultLogger::get()->warn(std::string("Found ") + s + " degenerated primitives");
} }
} }

10
code/FindInstancesProcess.cpp
View File

@ -119,7 +119,7 @@ void UpdateMeshIndices(aiNode* node, unsigned int* lookup)
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void FindInstancesProcess::Execute( aiScene* pScene) void FindInstancesProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("FindInstancesProcess begin"); ASSIMP_LOG_DEBUG("FindInstancesProcess begin");
if (pScene->mNumMeshes) { if (pScene->mNumMeshes) {
// use a pseudo hash for all meshes in the scene to quickly find // use a pseudo hash for all meshes in the scene to quickly find
@ -267,13 +267,11 @@ void FindInstancesProcess::Execute( aiScene* pScene)
// write to log // write to log
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
ASSIMP_LOG_INFO_F( "FindInstancesProcess finished. Found ", (pScene->mNumMeshes - numMeshesOut), " instances" );
char buffer[512];
::ai_snprintf(buffer,512,"FindInstancesProcess finished. Found %i instances",pScene->mNumMeshes-numMeshesOut);
DefaultLogger::get()->info(buffer);
} }
pScene->mNumMeshes = numMeshesOut; pScene->mNumMeshes = numMeshesOut;
} else {
ASSIMP_LOG_DEBUG("FindInstancesProcess finished. No instanced meshes found");
} }
else DefaultLogger::get()->debug("FindInstancesProcess finished. No instanced meshes found");
} }
} }

14
code/FindInvalidDataProcess.cpp
View File

@ -118,7 +118,7 @@ void UpdateMeshReferences(aiNode* node, const std::vector<unsigned int>& meshMap
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void FindInvalidDataProcess::Execute( aiScene* pScene) void FindInvalidDataProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("FindInvalidDataProcess begin"); ASSIMP_LOG_DEBUG("FindInvalidDataProcess begin");
bool out = false; bool out = false;
std::vector<unsigned int> meshMapping(pScene->mNumMeshes); std::vector<unsigned int> meshMapping(pScene->mNumMeshes);
@ -163,9 +163,10 @@ void FindInvalidDataProcess::Execute( aiScene* pScene)
pScene->mNumMeshes = real; pScene->mNumMeshes = real;
} }
DefaultLogger::get()->info("FindInvalidDataProcess finished. Found issues ..."); ASSIMP_LOG_INFO("FindInvalidDataProcess finished. Found issues ...");
} else {
ASSIMP_LOG_DEBUG("FindInvalidDataProcess finished. Everything seems to be OK.");
} }
else DefaultLogger::get()->debug("FindInvalidDataProcess finished. Everything seems to be OK.");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -212,8 +213,7 @@ inline bool ProcessArray(T*& in, unsigned int num,const char* name,
{ {
const char* err = ValidateArrayContents(in,num,dirtyMask,mayBeIdentical,mayBeZero); const char* err = ValidateArrayContents(in,num,dirtyMask,mayBeIdentical,mayBeZero);
if (err) { if (err) {
DefaultLogger::get()->error(std::string("FindInvalidDataProcess fails on mesh ") + name + ": " + err); ASSIMP_LOG_ERROR_F( "FindInvalidDataProcess fails on mesh ", name, ": ", err);
delete[] in; delete[] in;
in = NULL; in = NULL;
return true; return true;
@ -332,7 +332,7 @@ void FindInvalidDataProcess::ProcessAnimationChannel (aiNodeAnim* anim)
i = 1; i = 1;
} }
if (1 == i) if (1 == i)
DefaultLogger::get()->warn("Simplified dummy tracks with just one key"); ASSIMP_LOG_WARN("Simplified dummy tracks with just one key");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -354,7 +354,7 @@ int FindInvalidDataProcess::ProcessMesh (aiMesh* pMesh)
// Process vertex positions // Process vertex positions
if (pMesh->mVertices && ProcessArray(pMesh->mVertices, pMesh->mNumVertices, "positions", dirtyMask)) { if (pMesh->mVertices && ProcessArray(pMesh->mVertices, pMesh->mNumVertices, "positions", dirtyMask)) {
DefaultLogger::get()->error("Deleting mesh: Unable to continue without vertex positions"); ASSIMP_LOG_ERROR("Deleting mesh: Unable to continue without vertex positions");
return 2; return 2;
} }

38
code/FixNormalsStep.cpp
View File

@ -82,28 +82,35 @@ bool FixInfacingNormalsProcess::IsActive( unsigned int pFlags) const
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void FixInfacingNormalsProcess::Execute( aiScene* pScene) void FixInfacingNormalsProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("FixInfacingNormalsProcess begin"); ASSIMP_LOG_DEBUG("FixInfacingNormalsProcess begin");
bool bHas = false; bool bHas( false );
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) for (unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
if(ProcessMesh( pScene->mMeshes[a],a))bHas = true; if (ProcessMesh(pScene->mMeshes[a], a)) {
bHas = true;
}
}
if (bHas) if (bHas) {
DefaultLogger::get()->debug("FixInfacingNormalsProcess finished. Found issues."); ASSIMP_LOG_DEBUG("FixInfacingNormalsProcess finished. Found issues.");
else DefaultLogger::get()->debug("FixInfacingNormalsProcess finished. No changes to the scene."); } else {
ASSIMP_LOG_DEBUG("FixInfacingNormalsProcess finished. No changes to the scene.");
}
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Apply the step to the mesh // Apply the step to the mesh
bool FixInfacingNormalsProcess::ProcessMesh( aiMesh* pcMesh, unsigned int index) bool FixInfacingNormalsProcess::ProcessMesh( aiMesh* pcMesh, unsigned int index)
{ {
ai_assert(NULL != pcMesh); ai_assert(nullptr != pcMesh);
// Nothing to do if there are no model normals // Nothing to do if there are no model normals
if (!pcMesh->HasNormals())return false; if (!pcMesh->HasNormals()) {
return false;
}
// Compute the bounding box of both the model vertices + normals and // Compute the bounding box of both the model vertices + normals and
// the umodified model vertices. Then check whether the first BB // the unmodified model vertices. Then check whether the first BB
// is smaller than the second. In this case we can assume that the // is smaller than the second. In this case we can assume that the
// normals need to be flipped, although there are a few special cases .. // normals need to be flipped, although there are a few special cases ..
// convex, concave, planar models ... // convex, concave, planar models ...
@ -155,14 +162,9 @@ bool FixInfacingNormalsProcess::ProcessMesh( aiMesh* pcMesh, unsigned int index)
if (fDelta1_z < 0.05f * std::sqrt( fDelta1_y * fDelta1_x ))return false; if (fDelta1_z < 0.05f * std::sqrt( fDelta1_y * fDelta1_x ))return false;
// now compare the volumes of the bounding boxes // now compare the volumes of the bounding boxes
if (std::fabs(fDelta0_x * fDelta0_y * fDelta0_z) < if (std::fabs(fDelta0_x * fDelta0_y * fDelta0_z) < std::fabs(fDelta1_x * fDelta1_yz)) {
std::fabs(fDelta1_x * fDelta1_yz)) if (!DefaultLogger::isNullLogger()) {
{ ASSIMP_LOG_INFO_F("Mesh ", index, ": Normals are facing inwards (or the mesh is planar)", index);
if (!DefaultLogger::isNullLogger())
{
char buffer[128]; // should be sufficiently large
ai_snprintf(buffer,128,"Mesh %u: Normals are facing inwards (or the mesh is planar)",index);
DefaultLogger::get()->info(buffer);
} }
// Invert normals // Invert normals

17
code/GenFaceNormalsProcess.cpp
View File

@ -72,16 +72,14 @@ GenFaceNormalsProcess::~GenFaceNormalsProcess()
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Returns whether the processing step is present in the given flag field. // Returns whether the processing step is present in the given flag field.
bool GenFaceNormalsProcess::IsActive( unsigned int pFlags) const bool GenFaceNormalsProcess::IsActive( unsigned int pFlags) const {
{
return (pFlags & aiProcess_GenNormals) != 0; return (pFlags & aiProcess_GenNormals) != 0;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void GenFaceNormalsProcess::Execute( aiScene* pScene) void GenFaceNormalsProcess::Execute( aiScene* pScene) {
{ ASSIMP_LOG_DEBUG("GenFaceNormalsProcess begin");
DefaultLogger::get()->debug("GenFaceNormalsProcess begin");
if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) { if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here"); throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
@ -94,11 +92,12 @@ void GenFaceNormalsProcess::Execute( aiScene* pScene)
} }
} }
if (bHas) { if (bHas) {
DefaultLogger::get()->info("GenFaceNormalsProcess finished. " ASSIMP_LOG_INFO("GenFaceNormalsProcess finished. "
"Face normals have been calculated"); "Face normals have been calculated");
} else {
ASSIMP_LOG_DEBUG("GenFaceNormalsProcess finished. "
"Normals are already there");
} }
else DefaultLogger::get()->debug("GenFaceNormalsProcess finished. "
"Normals are already there");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -113,7 +112,7 @@ bool GenFaceNormalsProcess::GenMeshFaceNormals (aiMesh* pMesh)
// triangles or higher-order polygons the normal vectors // triangles or higher-order polygons the normal vectors
// are undefined. // are undefined.
if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) { if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) {
DefaultLogger::get()->info("Normal vectors are undefined for line and point meshes"); ASSIMP_LOG_INFO("Normal vectors are undefined for line and point meshes");
return false; return false;
} }

17
code/GenVertexNormalsProcess.cpp
View File

@ -88,24 +88,25 @@ void GenVertexNormalsProcess::SetupProperties(const Importer* pImp)
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void GenVertexNormalsProcess::Execute( aiScene* pScene) void GenVertexNormalsProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("GenVertexNormalsProcess begin"); ASSIMP_LOG_DEBUG("GenVertexNormalsProcess begin");
if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) if (pScene->mFlags & AI_SCENE_FLAGS_NON_VERBOSE_FORMAT) {
throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here"); throw DeadlyImportError("Post-processing order mismatch: expecting pseudo-indexed (\"verbose\") vertices here");
}
bool bHas = false; bool bHas = false;
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) for( unsigned int a = 0; a < pScene->mNumMeshes; ++a) {
{
if(GenMeshVertexNormals( pScene->mMeshes[a],a)) if(GenMeshVertexNormals( pScene->mMeshes[a],a))
bHas = true; bHas = true;
} }
if (bHas) { if (bHas) {
DefaultLogger::get()->info("GenVertexNormalsProcess finished. " ASSIMP_LOG_INFO("GenVertexNormalsProcess finished. "
"Vertex normals have been calculated"); "Vertex normals have been calculated");
} else {
ASSIMP_LOG_DEBUG("GenVertexNormalsProcess finished. "
"Normals are already there");
} }
else DefaultLogger::get()->debug("GenVertexNormalsProcess finished. "
"Normals are already there");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -120,7 +121,7 @@ bool GenVertexNormalsProcess::GenMeshVertexNormals (aiMesh* pMesh, unsigned int
// are undefined. // are undefined.
if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON))) if (!(pMesh->mPrimitiveTypes & (aiPrimitiveType_TRIANGLE | aiPrimitiveType_POLYGON)))
{ {
DefaultLogger::get()->info("Normal vectors are undefined for line and point meshes"); ASSIMP_LOG_INFO("Normal vectors are undefined for line and point meshes");
return false; return false;
} }

6
code/HMPLoader.cpp
View File

@ -141,21 +141,21 @@ void HMPImporter::InternReadFile( const std::string& pFile,
if (AI_HMP_MAGIC_NUMBER_LE_4 == iMagic || if (AI_HMP_MAGIC_NUMBER_LE_4 == iMagic ||
AI_HMP_MAGIC_NUMBER_BE_4 == iMagic) AI_HMP_MAGIC_NUMBER_BE_4 == iMagic)
{ {
DefaultLogger::get()->debug("HMP subtype: 3D GameStudio A4, magic word is HMP4"); ASSIMP_LOG_DEBUG("HMP subtype: 3D GameStudio A4, magic word is HMP4");
InternReadFile_HMP4(); InternReadFile_HMP4();
} }
// HMP5 format // HMP5 format
else if (AI_HMP_MAGIC_NUMBER_LE_5 == iMagic || else if (AI_HMP_MAGIC_NUMBER_LE_5 == iMagic ||
AI_HMP_MAGIC_NUMBER_BE_5 == iMagic) AI_HMP_MAGIC_NUMBER_BE_5 == iMagic)
{ {
DefaultLogger::get()->debug("HMP subtype: 3D GameStudio A5, magic word is HMP5"); ASSIMP_LOG_DEBUG("HMP subtype: 3D GameStudio A5, magic word is HMP5");
InternReadFile_HMP5(); InternReadFile_HMP5();
} }
// HMP7 format // HMP7 format
else if (AI_HMP_MAGIC_NUMBER_LE_7 == iMagic || else if (AI_HMP_MAGIC_NUMBER_LE_7 == iMagic ||
AI_HMP_MAGIC_NUMBER_BE_7 == iMagic) AI_HMP_MAGIC_NUMBER_BE_7 == iMagic)
{ {
DefaultLogger::get()->debug("HMP subtype: 3D GameStudio A7, magic word is HMP7"); ASSIMP_LOG_DEBUG("HMP subtype: 3D GameStudio A7, magic word is HMP7");
InternReadFile_HMP7(); InternReadFile_HMP7();
} }
else else

56
code/IRRLoader.cpp
View File

@ -131,7 +131,7 @@ void IRRImporter::SetupProperties(const Importer* pImp)
// read the output frame rate of all node animation channels // read the output frame rate of all node animation channels
fps = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IRR_ANIM_FPS,100); fps = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IRR_ANIM_FPS,100);
if (fps < 10.) { if (fps < 10.) {
DefaultLogger::get()->error("IRR: Invalid FPS configuration"); ASSIMP_LOG_ERROR("IRR: Invalid FPS configuration");
fps = 100; fps = 100;
} }
@ -281,7 +281,7 @@ void IRRImporter::CopyMaterial(std::vector<aiMaterial*>& materials,
return; return;
} }
else if (inmaterials.size() > 1) { else if (inmaterials.size() > 1) {
DefaultLogger::get()->info("IRR: Skipping additional materials"); ASSIMP_LOG_INFO("IRR: Skipping additional materials");
} }
mesh->mMaterialIndex = (unsigned int)materials.size(); mesh->mMaterialIndex = (unsigned int)materials.size();
@ -319,17 +319,18 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
if (root->animators.empty()) { if (root->animators.empty()) {
return; return;
} }
unsigned int total = 0; unsigned int total( 0 );
for (std::list<Animator>::iterator it = root->animators.begin();it != root->animators.end(); ++it) { for (std::list<Animator>::iterator it = root->animators.begin();it != root->animators.end(); ++it) {
if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) { if ((*it).type == Animator::UNKNOWN || (*it).type == Animator::OTHER) {
DefaultLogger::get()->warn("IRR: Skipping unknown or unsupported animator"); ASSIMP_LOG_WARN("IRR: Skipping unknown or unsupported animator");
continue; continue;
} }
++total; ++total;
} }
if (!total)return; if (!total) {
else if (1 == total) { return;
DefaultLogger::get()->warn("IRR: Adding dummy nodes to simulate multiple animators"); } else if (1 == total) {
ASSIMP_LOG_WARN("IRR: Adding dummy nodes to simulate multiple animators");
} }
// NOTE: 1 tick == i millisecond // NOTE: 1 tick == i millisecond
@ -518,9 +519,9 @@ void IRRImporter::ComputeAnimations(Node* root, aiNode* real, std::vector<aiNode
const int size = (int)in.splineKeys.size(); const int size = (int)in.splineKeys.size();
if (!size) { if (!size) {
// We have no point in the spline. That's bad. Really bad. // We have no point in the spline. That's bad. Really bad.
DefaultLogger::get()->warn("IRR: Spline animators with no points defined"); ASSIMP_LOG_WARN("IRR: Spline animators with no points defined");
delete anim;anim = NULL; delete anim;anim = nullptr;
break; break;
} }
else if (size == 1) { else if (size == 1) {
@ -672,7 +673,7 @@ void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
// graph we're currently building // graph we're currently building
aiScene* scene = batch.GetImport(root->id); aiScene* scene = batch.GetImport(root->id);
if (!scene) { if (!scene) {
DefaultLogger::get()->error("IRR: Unable to load external file: " + root->meshPath); ASSIMP_LOG_ERROR("IRR: Unable to load external file: " + root->meshPath);
break; break;
} }
attach.push_back(AttachmentInfo(scene,rootOut)); attach.push_back(AttachmentInfo(scene,rootOut));
@ -683,7 +684,7 @@ void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
// should be equal. If they are not, we can impossibly // should be equal. If they are not, we can impossibly
// do this ... // do this ...
if (root->materials.size() != (unsigned int)scene->mNumMaterials) { if (root->materials.size() != (unsigned int)scene->mNumMaterials) {
DefaultLogger::get()->warn("IRR: Failed to match imported materials " ASSIMP_LOG_WARN("IRR: Failed to match imported materials "
"with the materials found in the IRR scene file"); "with the materials found in the IRR scene file");
break; break;
@ -722,7 +723,7 @@ void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
} }
} }
if (bdo) { if (bdo) {
DefaultLogger::get()->info("IRR: Replacing mesh vertex alpha with common opacity"); ASSIMP_LOG_INFO("IRR: Replacing mesh vertex alpha with common opacity");
for (unsigned int a = 0; a < mesh->mNumVertices;++a) for (unsigned int a = 0; a < mesh->mNumVertices;++a)
mesh->mColors[0][a].a = 1.f; mesh->mColors[0][a].a = 1.f;
@ -806,7 +807,7 @@ void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
{ {
// A skybox is defined by six materials // A skybox is defined by six materials
if (root->materials.size() < 6) { if (root->materials.size() < 6) {
DefaultLogger::get()->error("IRR: There should be six materials for a skybox"); ASSIMP_LOG_ERROR("IRR: There should be six materials for a skybox");
break; break;
} }
@ -823,7 +824,7 @@ void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
// for IRR skyboxes. We add a 'IRR.SkyBox_' prefix to the node. // for IRR skyboxes. We add a 'IRR.SkyBox_' prefix to the node.
// ************************************************************* // *************************************************************
root->name = "IRR.SkyBox_" + root->name; root->name = "IRR.SkyBox_" + root->name;
DefaultLogger::get()->info("IRR: Loading skybox, this will " ASSIMP_LOG_INFO("IRR: Loading skybox, this will "
"require special handling to be displayed correctly"); "require special handling to be displayed correctly");
} }
break; break;
@ -831,7 +832,7 @@ void IRRImporter::GenerateGraph(Node* root,aiNode* rootOut ,aiScene* scene,
case Node::TERRAIN: case Node::TERRAIN:
{ {
// to support terrains, we'd need to have a texture decoder // to support terrains, we'd need to have a texture decoder
DefaultLogger::get()->error("IRR: Unsupported node - TERRAIN"); ASSIMP_LOG_ERROR("IRR: Unsupported node - TERRAIN");
} }
break; break;
default: default:
@ -1010,11 +1011,11 @@ void IRRImporter::InternReadFile( const std::string& pFile,
} }
else if (!ASSIMP_stricmp(sz,"billBoard")) { else if (!ASSIMP_stricmp(sz,"billBoard")) {
// We don't support billboards, so ignore them // We don't support billboards, so ignore them
DefaultLogger::get()->error("IRR: Billboards are not supported by Assimp"); ASSIMP_LOG_ERROR("IRR: Billboards are not supported by Assimp");
nd = new Node(Node::DUMMY); nd = new Node(Node::DUMMY);
} }
else { else {
DefaultLogger::get()->warn("IRR: Found unknown node: " + std::string(sz)); ASSIMP_LOG_WARN("IRR: Found unknown node: " + std::string(sz));
/* We skip the contents of nodes we don't know. /* We skip the contents of nodes we don't know.
* We parse the transformation and all animators * We parse the transformation and all animators
@ -1041,7 +1042,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
*/ */
if (!curNode) { if (!curNode) {
#if 0 #if 0
DefaultLogger::get()->error("IRR: Encountered <attributes> element, but " ASSIMP_LOG_ERROR("IRR: Encountered <attributes> element, but "
"there is no node active"); "there is no node active");
#endif #endif
continue; continue;
@ -1269,7 +1270,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
lights.pop_back(); lights.pop_back();
curNode->type = Node::DUMMY; curNode->type = Node::DUMMY;
DefaultLogger::get()->error("Ignoring light of unknown type: " + prop.value); ASSIMP_LOG_ERROR("Ignoring light of unknown type: " + prop.value);
} }
} }
else if ((prop.name == "Mesh" && Node::MESH == curNode->type) || else if ((prop.name == "Mesh" && Node::MESH == curNode->type) ||
@ -1277,7 +1278,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
{ {
/* This is the file name of the mesh - either /* This is the file name of the mesh - either
* animated or not. We need to make sure we setup * animated or not. We need to make sure we setup
* the correct postprocessing settings here. * the correct post-processing settings here.
*/ */
unsigned int pp = 0; unsigned int pp = 0;
BatchLoader::PropertyMap map; BatchLoader::PropertyMap map;
@ -1299,7 +1300,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
const std::string extension = GetExtension(prop.value); const std::string extension = GetExtension(prop.value);
if ("irr" == extension) { if ("irr" == extension) {
DefaultLogger::get()->error("IRR: Can't load another IRR file recursively"); ASSIMP_LOG_ERROR("IRR: Can't load another IRR file recursively");
} }
else else
{ {
@ -1323,7 +1324,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
curAnim->type = Animator::FOLLOW_SPLINE; curAnim->type = Animator::FOLLOW_SPLINE;
} }
else { else {
DefaultLogger::get()->warn("IRR: Ignoring unknown animator: " ASSIMP_LOG_WARN("IRR: Ignoring unknown animator: "
+ prop.value); + prop.value);
curAnim->type = Animator::UNKNOWN; curAnim->type = Animator::UNKNOWN;
@ -1348,7 +1349,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
// back in the node hierarchy // back in the node hierarchy
if (!curParent) { if (!curParent) {
curParent = root; curParent = root;
DefaultLogger::get()->error("IRR: Too many closing <node> elements"); ASSIMP_LOG_ERROR("IRR: Too many closing <node> elements");
} }
else curParent = curParent->parent; else curParent = curParent->parent;
} }
@ -1369,15 +1370,14 @@ void IRRImporter::InternReadFile( const std::string& pFile,
} }
} }
/* Now iterate through all cameras and compute their final (horizontal) FOV // Now iterate through all cameras and compute their final (horizontal) FOV
*/
for (aiCamera *cam : cameras) { for (aiCamera *cam : cameras) {
// screen aspect could be missing // screen aspect could be missing
if (cam->mAspect) { if (cam->mAspect) {
cam->mHorizontalFOV *= cam->mAspect; cam->mHorizontalFOV *= cam->mAspect;
} else {
ASSIMP_LOG_WARN("IRR: Camera aspect is not given, can't compute horizontal FOV");
} }
else DefaultLogger::get()->warn("IRR: Camera aspect is not given, can't compute horizontal FOV");
} }
batch.LoadAll(); batch.LoadAll();
@ -1472,7 +1472,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
* models from external files * models from external files
*/ */
if (!pScene->mNumMeshes || !pScene->mNumMaterials) { if (!pScene->mNumMeshes || !pScene->mNumMaterials) {
DefaultLogger::get()->warn("IRR: No meshes loaded, setting AI_SCENE_FLAGS_INCOMPLETE"); ASSIMP_LOG_WARN("IRR: No meshes loaded, setting AI_SCENE_FLAGS_INCOMPLETE");
pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
} }

20
code/IRRMeshLoader.cpp
View File

@ -175,7 +175,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
if (!ASSIMP_stricmp(reader->getNodeName(),"buffer") && (curMat || curMesh)) { if (!ASSIMP_stricmp(reader->getNodeName(),"buffer") && (curMat || curMesh)) {
// end of previous buffer. A material and a mesh should be there // end of previous buffer. A material and a mesh should be there
if ( !curMat || !curMesh) { if ( !curMat || !curMesh) {
DefaultLogger::get()->error("IRRMESH: A buffer must contain a mesh and a material"); ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
releaseMaterial( &curMat ); releaseMaterial( &curMat );
releaseMesh( &curMesh ); releaseMesh( &curMesh );
} else { } else {
@ -197,7 +197,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
if (!ASSIMP_stricmp(reader->getNodeName(),"material")) { if (!ASSIMP_stricmp(reader->getNodeName(),"material")) {
if (curMat) { if (curMat) {
DefaultLogger::get()->warn("IRRMESH: Only one material description per buffer, please"); ASSIMP_LOG_WARN("IRRMESH: Only one material description per buffer, please");
releaseMaterial( &curMat ); releaseMaterial( &curMat );
} }
curMat = ParseMaterial(curMatFlags); curMat = ParseMaterial(curMatFlags);
@ -208,7 +208,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
if (!num) { if (!num) {
// This is possible ... remove the mesh from the list and skip further reading // This is possible ... remove the mesh from the list and skip further reading
DefaultLogger::get()->warn("IRRMESH: Found mesh with zero vertices"); ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero vertices");
releaseMaterial( &curMat ); releaseMaterial( &curMat );
releaseMesh( &curMesh ); releaseMesh( &curMesh );
@ -255,7 +255,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
} }
else if (ASSIMP_stricmp("standard", t)) { else if (ASSIMP_stricmp("standard", t)) {
releaseMaterial( &curMat ); releaseMaterial( &curMat );
DefaultLogger::get()->warn("IRRMESH: Unknown vertex format"); ASSIMP_LOG_WARN("IRRMESH: Unknown vertex format");
} }
else vertexFormat = 0; else vertexFormat = 0;
textMeaning = 1; textMeaning = 1;
@ -275,7 +275,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
curMesh->mNumVertices = reader->getAttributeValueAsInt("indexCount"); curMesh->mNumVertices = reader->getAttributeValueAsInt("indexCount");
if (!curMesh->mNumVertices) { if (!curMesh->mNumVertices) {
// This is possible ... remove the mesh from the list and skip further reading // This is possible ... remove the mesh from the list and skip further reading
DefaultLogger::get()->warn("IRRMESH: Found mesh with zero indices"); ASSIMP_LOG_WARN("IRRMESH: Found mesh with zero indices");
// mesh - away // mesh - away
releaseMesh( &curMesh ); releaseMesh( &curMesh );
@ -288,7 +288,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
} }
if (curMesh->mNumVertices % 3) { if (curMesh->mNumVertices % 3) {
DefaultLogger::get()->warn("IRRMESH: Number if indices isn't divisible by 3"); ASSIMP_LOG_WARN("IRRMESH: Number if indices isn't divisible by 3");
} }
curMesh->mNumFaces = curMesh->mNumVertices / 3; curMesh->mNumFaces = curMesh->mNumVertices / 3;
@ -439,7 +439,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
unsigned int total = 0; unsigned int total = 0;
while(SkipSpacesAndLineEnd(&sz)) { while(SkipSpacesAndLineEnd(&sz)) {
if (curFace >= faceEnd) { if (curFace >= faceEnd) {
DefaultLogger::get()->error("IRRMESH: Too many indices"); ASSIMP_LOG_ERROR("IRRMESH: Too many indices");
break; break;
} }
if (!curIdx) { if (!curIdx) {
@ -449,7 +449,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
unsigned int idx = strtoul10(sz,&sz); unsigned int idx = strtoul10(sz,&sz);
if (idx >= curVertices.size()) { if (idx >= curVertices.size()) {
DefaultLogger::get()->error("IRRMESH: Index out of range"); ASSIMP_LOG_ERROR("IRRMESH: Index out of range");
idx = 0; idx = 0;
} }
@ -470,7 +470,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
} }
if (curFace != faceEnd) if (curFace != faceEnd)
DefaultLogger::get()->error("IRRMESH: Not enough indices"); ASSIMP_LOG_ERROR("IRRMESH: Not enough indices");
// Finish processing the mesh - do some small material workarounds // Finish processing the mesh - do some small material workarounds
if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) { if (curMatFlags & AI_IRRMESH_MAT_trans_vertex_alpha && !useColors) {
@ -492,7 +492,7 @@ void IRRMeshImporter::InternReadFile( const std::string& pFile,
// End of the last buffer. A material and a mesh should be there // End of the last buffer. A material and a mesh should be there
if (curMat || curMesh) { if (curMat || curMesh) {
if ( !curMat || !curMesh) { if ( !curMat || !curMesh) {
DefaultLogger::get()->error("IRRMESH: A buffer must contain a mesh and a material"); ASSIMP_LOG_ERROR("IRRMESH: A buffer must contain a mesh and a material");
releaseMaterial( &curMat ); releaseMaterial( &curMat );
releaseMesh( &curMesh ); releaseMesh( &curMesh );
} }

25
code/IRRShared.cpp
View File

@ -179,14 +179,14 @@ void IrrlichtBase::ReadVectorProperty (VectorProperty& out)
SkipSpaces(&ptr); SkipSpaces(&ptr);
if (',' != *ptr) if (',' != *ptr)
{ {
DefaultLogger::get()->error("IRR(MESH): Expected comma in vector definition"); ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
} }
else SkipSpaces(ptr+1,&ptr); else SkipSpaces(ptr+1,&ptr);
ptr = fast_atoreal_move<float>( ptr,(float&)out.value.y ); ptr = fast_atoreal_move<float>( ptr,(float&)out.value.y );
SkipSpaces(&ptr); SkipSpaces(&ptr);
if (',' != *ptr) if (',' != *ptr)
{ {
DefaultLogger::get()->error("IRR(MESH): Expected comma in vector definition"); ASSIMP_LOG_ERROR("IRR(MESH): Expected comma in vector definition");
} }
else SkipSpaces(ptr+1,&ptr); else SkipSpaces(ptr+1,&ptr);
ptr = fast_atoreal_move<float>( ptr,(float&)out.value.z ); ptr = fast_atoreal_move<float>( ptr,(float&)out.value.z );
@ -360,7 +360,7 @@ aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
matFlags = AI_IRRMESH_MAT_normalmap_ta; matFlags = AI_IRRMESH_MAT_normalmap_ta;
} }
else { else {
DefaultLogger::get()->warn("IRRMat: Unrecognized material type: " + prop.value); ASSIMP_LOG_WARN("IRRMat: Unrecognized material type: " + prop.value);
} }
} }
@ -391,9 +391,7 @@ aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
// set the corresponding material flag // set the corresponding material flag
matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
} } else if (matFlags & AI_IRRMESH_MAT_solid_2layer) {// or just as second diffuse texture
// or just as second diffuse texture
else if (matFlags & AI_IRRMESH_MAT_solid_2layer) {
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(1)); mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(1));
@ -401,19 +399,15 @@ aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
// set the corresponding material flag // set the corresponding material flag
matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE; matFlags |= AI_IRRMESH_EXTRA_2ND_TEXTURE;
} else {
ASSIMP_LOG_WARN("IRRmat: Skipping second texture");
} }
else DefaultLogger::get()->warn("IRRmat: Skipping second texture"); } else if (prop.name == "Texture3" && cnt == 2) {
}
else if (prop.name == "Texture3" && cnt == 2)
{
// Irrlicht does not seem to use these channels. // Irrlicht does not seem to use these channels.
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(nd+1)); mat->AddProperty(&s,AI_MATKEY_TEXTURE_DIFFUSE(nd+1));
} } else if (prop.name == "Texture4" && cnt == 3) {
else if (prop.name == "Texture4" && cnt == 3)
{
// Irrlicht does not seem to use these channels. // Irrlicht does not seem to use these channels.
++cnt; ++cnt;
s.Set(prop.value); s.Set(prop.value);
@ -499,7 +493,8 @@ aiMaterial* IrrlichtBase::ParseMaterial(unsigned int& matFlags)
break; break;
} }
} }
DefaultLogger::get()->error("IRRMESH: Unexpected end of file. Material is not complete"); ASSIMP_LOG_ERROR("IRRMESH: Unexpected end of file. Material is not complete");
return mat; return mat;
} }

88
code/Importer.cpp
View File

@ -205,7 +205,7 @@ aiReturn Importer::RegisterPPStep(BaseProcess* pImp)
ASSIMP_BEGIN_EXCEPTION_REGION(); ASSIMP_BEGIN_EXCEPTION_REGION();
pimpl->mPostProcessingSteps.push_back(pImp); pimpl->mPostProcessingSteps.push_back(pImp);
DefaultLogger::get()->info("Registering custom post-processing step"); ASSIMP_LOG_INFO("Registering custom post-processing step");
ASSIMP_END_EXCEPTION_REGION(aiReturn); ASSIMP_END_EXCEPTION_REGION(aiReturn);
return AI_SUCCESS; return AI_SUCCESS;
@ -232,7 +232,7 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp)
#ifdef ASSIMP_BUILD_DEBUG #ifdef ASSIMP_BUILD_DEBUG
if (IsExtensionSupported(*it)) { if (IsExtensionSupported(*it)) {
DefaultLogger::get()->warn("The file extension " + *it + " is already in use"); ASSIMP_LOG_WARN_F("The file extension ", *it, " is already in use");
} }
#endif #endif
baked += *it; baked += *it;
@ -240,7 +240,7 @@ aiReturn Importer::RegisterLoader(BaseImporter* pImp)
// add the loader // add the loader
pimpl->mImporter.push_back(pImp); pimpl->mImporter.push_back(pImp);
DefaultLogger::get()->info("Registering custom importer for these file extensions: " + baked); ASSIMP_LOG_INFO_F("Registering custom importer for these file extensions: ", baked);
ASSIMP_END_EXCEPTION_REGION(aiReturn); ASSIMP_END_EXCEPTION_REGION(aiReturn);
return AI_SUCCESS; return AI_SUCCESS;
} }
@ -260,10 +260,10 @@ aiReturn Importer::UnregisterLoader(BaseImporter* pImp)
if (it != pimpl->mImporter.end()) { if (it != pimpl->mImporter.end()) {
pimpl->mImporter.erase(it); pimpl->mImporter.erase(it);
DefaultLogger::get()->info("Unregistering custom importer: "); ASSIMP_LOG_INFO("Unregistering custom importer: ");
return AI_SUCCESS; return AI_SUCCESS;
} }
DefaultLogger::get()->warn("Unable to remove custom importer: I can't find you ..."); ASSIMP_LOG_WARN("Unable to remove custom importer: I can't find you ...");
ASSIMP_END_EXCEPTION_REGION(aiReturn); ASSIMP_END_EXCEPTION_REGION(aiReturn);
return AI_FAILURE; return AI_FAILURE;
} }
@ -283,10 +283,10 @@ aiReturn Importer::UnregisterPPStep(BaseProcess* pImp)
if (it != pimpl->mPostProcessingSteps.end()) { if (it != pimpl->mPostProcessingSteps.end()) {
pimpl->mPostProcessingSteps.erase(it); pimpl->mPostProcessingSteps.erase(it);
DefaultLogger::get()->info("Unregistering custom post-processing step"); ASSIMP_LOG_INFO("Unregistering custom post-processing step");
return AI_SUCCESS; return AI_SUCCESS;
} }
DefaultLogger::get()->warn("Unable to remove custom post-processing step: I can't find you .."); ASSIMP_LOG_WARN("Unable to remove custom post-processing step: I can't find you ..");
ASSIMP_END_EXCEPTION_REGION(aiReturn); ASSIMP_END_EXCEPTION_REGION(aiReturn);
return AI_FAILURE; return AI_FAILURE;
} }
@ -368,11 +368,11 @@ bool Importer::IsDefaultProgressHandler() const
bool _ValidateFlags(unsigned int pFlags) bool _ValidateFlags(unsigned int pFlags)
{ {
if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals) { if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals) {
DefaultLogger::get()->error("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible"); ASSIMP_LOG_ERROR("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible");
return false; return false;
} }
if (pFlags & aiProcess_OptimizeGraph && pFlags & aiProcess_PreTransformVertices) { if (pFlags & aiProcess_OptimizeGraph && pFlags & aiProcess_PreTransformVertices) {
DefaultLogger::get()->error("#aiProcess_OptimizeGraph and #aiProcess_PreTransformVertices are incompatible"); ASSIMP_LOG_ERROR("#aiProcess_OptimizeGraph and #aiProcess_PreTransformVertices are incompatible");
return false; return false;
} }
return true; return true;
@ -504,26 +504,15 @@ const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void WriteLogOpening(const std::string& file) void WriteLogOpening(const std::string& file)
{ {
Logger* l = DefaultLogger::get(); ASSIMP_LOG_INFO_F("Load ", file);
if (!l) {
return;
}
l->info("Load " + file);
// print a full version dump. This is nice because we don't // print a full version dump. This is nice because we don't
// need to ask the authors of incoming bug reports for // need to ask the authors of incoming bug reports for
// the library version they're using - a log dump is // the library version they're using - a log dump is
// sufficient. // sufficient.
const unsigned int flags = aiGetCompileFlags(); const unsigned int flags( aiGetCompileFlags() );
l->debug(format() std::stringstream stream;
<< "Assimp " stream << "Assimp " << aiGetVersionMajor() << "." << aiGetVersionMinor() << "." << aiGetVersionRevision() << " "
<< aiGetVersionMajor()
<< "."
<< aiGetVersionMinor()
<< "."
<< aiGetVersionRevision()
<< " "
#if defined(ASSIMP_BUILD_ARCHITECTURE) #if defined(ASSIMP_BUILD_ARCHITECTURE)
<< ASSIMP_BUILD_ARCHITECTURE << ASSIMP_BUILD_ARCHITECTURE
#elif defined(_M_IX86) || defined(__x86_32__) || defined(__i386__) #elif defined(_M_IX86) || defined(__x86_32__) || defined(__i386__)
@ -539,12 +528,11 @@ void WriteLogOpening(const std::string& file)
#elif defined(__arm__) #elif defined(__arm__)
<< "arm" << "arm"
#else #else
<< "<unknown architecture>" << "<unknown architecture>"
#endif #endif
<< " " << " "
#if defined(ASSIMP_BUILD_COMPILER) #if defined(ASSIMP_BUILD_COMPILER)
<< ASSIMP_BUILD_COMPILER << ( ASSIMP_BUILD_COMPILER )
#elif defined(_MSC_VER) #elif defined(_MSC_VER)
<< "msvc" << "msvc"
#elif defined(__GNUC__) #elif defined(__GNUC__)
@ -559,8 +547,9 @@ void WriteLogOpening(const std::string& file)
<< (flags & ASSIMP_CFLAGS_NOBOOST ? " noboost" : "") << (flags & ASSIMP_CFLAGS_NOBOOST ? " noboost" : "")
<< (flags & ASSIMP_CFLAGS_SHARED ? " shared" : "") << (flags & ASSIMP_CFLAGS_SHARED ? " shared" : "")
<< (flags & ASSIMP_CFLAGS_SINGLETHREADED ? " singlethreaded" : "") << (flags & ASSIMP_CFLAGS_SINGLETHREADED ? " singlethreaded" : "");
);
ASSIMP_LOG_DEBUG(stream.str());
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -586,7 +575,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
// a scene. In this case we need to delete the old one // a scene. In this case we need to delete the old one
if (pimpl->mScene) { if (pimpl->mScene) {
DefaultLogger::get()->debug("(Deleting previous scene)"); ASSIMP_LOG_DEBUG("(Deleting previous scene)");
FreeScene(); FreeScene();
} }
@ -594,7 +583,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
if( !pimpl->mIOHandler->Exists( pFile)) { if( !pimpl->mIOHandler->Exists( pFile)) {
pimpl->mErrorString = "Unable to open file \"" + pFile + "\"."; pimpl->mErrorString = "Unable to open file \"" + pFile + "\".";
DefaultLogger::get()->error(pimpl->mErrorString); ASSIMP_LOG_ERROR(pimpl->mErrorString);
return NULL; return NULL;
} }
@ -617,7 +606,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
// not so bad yet ... try format auto detection. // not so bad yet ... try format auto detection.
const std::string::size_type s = pFile.find_last_of('.'); const std::string::size_type s = pFile.find_last_of('.');
if (s != std::string::npos) { if (s != std::string::npos) {
DefaultLogger::get()->info("File extension not known, trying signature-based detection"); ASSIMP_LOG_INFO("File extension not known, trying signature-based detection");
for( unsigned int a = 0; a < pimpl->mImporter.size(); a++) { for( unsigned int a = 0; a < pimpl->mImporter.size(); a++) {
if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) { if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) {
imp = pimpl->mImporter[a]; imp = pimpl->mImporter[a];
@ -628,7 +617,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
// Put a proper error message if no suitable importer was found // Put a proper error message if no suitable importer was found
if( !imp) { if( !imp) {
pimpl->mErrorString = "No suitable reader found for the file format of file \"" + pFile + "\"."; pimpl->mErrorString = "No suitable reader found for the file format of file \"" + pFile + "\".";
DefaultLogger::get()->error(pimpl->mErrorString); ASSIMP_LOG_ERROR(pimpl->mErrorString);
return NULL; return NULL;
} }
} }
@ -648,7 +637,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
if ( NULL != desc ) { if ( NULL != desc ) {
ext = desc->mName; ext = desc->mName;
} }
DefaultLogger::get()->info("Found a matching importer for this file format: " + ext + "." ); ASSIMP_LOG_INFO("Found a matching importer for this file format: " + ext + "." );
pimpl->mProgressHandler->UpdateFileRead( 0, fileSize ); pimpl->mProgressHandler->UpdateFileRead( 0, fileSize );
if (profiler) { if (profiler) {
@ -716,7 +705,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
pimpl->mErrorString = std::string("std::exception: ") + e.what(); pimpl->mErrorString = std::string("std::exception: ") + e.what();
#endif #endif
DefaultLogger::get()->error(pimpl->mErrorString); ASSIMP_LOG_ERROR(pimpl->mErrorString);
delete pimpl->mScene; pimpl->mScene = NULL; delete pimpl->mScene; pimpl->mScene = NULL;
} }
#endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS #endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS
@ -744,7 +733,7 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
// In debug builds: run basic flag validation // In debug builds: run basic flag validation
ai_assert(_ValidateFlags(pFlags)); ai_assert(_ValidateFlags(pFlags));
DefaultLogger::get()->info("Entering post processing pipeline"); ASSIMP_LOG_INFO("Entering post processing pipeline");
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
// The ValidateDS process plays an exceptional role. It isn't contained in the global // The ValidateDS process plays an exceptional role. It isn't contained in the global
@ -762,13 +751,13 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
if (pimpl->bExtraVerbose) if (pimpl->bExtraVerbose)
{ {
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS #ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
DefaultLogger::get()->error("Verbose Import is not available due to build settings"); ASSIMP_LOG_ERROR("Verbose Import is not available due to build settings");
#endif // no validation #endif // no validation
pFlags |= aiProcess_ValidateDataStructure; pFlags |= aiProcess_ValidateDataStructure;
} }
#else #else
if (pimpl->bExtraVerbose) { if (pimpl->bExtraVerbose) {
DefaultLogger::get()->warn("Not a debug build, ignoring extra verbose setting"); ASSIMP_LOG_WARN("Not a debug build, ignoring extra verbose setting");
} }
#endif // ! DEBUG #endif // ! DEBUG
@ -800,18 +789,19 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step // If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
if (pimpl->bExtraVerbose) { if (pimpl->bExtraVerbose) {
DefaultLogger::get()->debug("Verbose Import: revalidating data structures"); ASSIMP_LOG_DEBUG("Verbose Import: re-validating data structures");
ValidateDSProcess ds; ValidateDSProcess ds;
ds.ExecuteOnScene (this); ds.ExecuteOnScene (this);
if( !pimpl->mScene) { if( !pimpl->mScene) {
DefaultLogger::get()->error("Verbose Import: failed to revalidate data structures"); ASSIMP_LOG_ERROR("Verbose Import: failed to re-validate data structures");
break; break;
} }
} }
#endif // ! DEBUG #endif // ! DEBUG
} }
pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()), static_cast<int>(pimpl->mPostProcessingSteps.size()) ); pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()),
static_cast<int>(pimpl->mPostProcessingSteps.size()) );
// update private scene flags // update private scene flags
if( pimpl->mScene ) if( pimpl->mScene )
@ -819,7 +809,7 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
// clear any data allocated by post-process steps // clear any data allocated by post-process steps
pimpl->mPPShared->Clean(); pimpl->mPPShared->Clean();
DefaultLogger::get()->info("Leaving post processing pipeline"); ASSIMP_LOG_INFO("Leaving post processing pipeline");
ASSIMP_END_EXCEPTION_REGION(const aiScene*); ASSIMP_END_EXCEPTION_REGION(const aiScene*);
return pimpl->mScene; return pimpl->mScene;
@ -840,7 +830,7 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
} }
// In debug builds: run basic flag validation // In debug builds: run basic flag validation
DefaultLogger::get()->info( "Entering customized post processing pipeline" ); ASSIMP_LOG_INFO( "Entering customized post processing pipeline" );
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
// The ValidateDS process plays an exceptional role. It isn't contained in the global // The ValidateDS process plays an exceptional role. It isn't contained in the global
@ -858,12 +848,12 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
if ( pimpl->bExtraVerbose ) if ( pimpl->bExtraVerbose )
{ {
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS #ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
DefaultLogger::get()->error( "Verbose Import is not available due to build settings" ); ASSIMP_LOG_ERROR( "Verbose Import is not available due to build settings" );
#endif // no validation #endif // no validation
} }
#else #else
if ( pimpl->bExtraVerbose ) { if ( pimpl->bExtraVerbose ) {
DefaultLogger::get()->warn( "Not a debug build, ignoring extra verbose setting" ); ASSIMP_LOG_WARN( "Not a debug build, ignoring extra verbose setting" );
} }
#endif // ! DEBUG #endif // ! DEBUG
@ -881,18 +871,18 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step // If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
if ( pimpl->bExtraVerbose || requestValidation ) { if ( pimpl->bExtraVerbose || requestValidation ) {
DefaultLogger::get()->debug( "Verbose Import: revalidating data structures" ); ASSIMP_LOG_DEBUG( "Verbose Import: revalidating data structures" );
ValidateDSProcess ds; ValidateDSProcess ds;
ds.ExecuteOnScene( this ); ds.ExecuteOnScene( this );
if ( !pimpl->mScene ) { if ( !pimpl->mScene ) {
DefaultLogger::get()->error( "Verbose Import: failed to revalidate data structures" ); ASSIMP_LOG_ERROR( "Verbose Import: failed to revalidate data structures" );
} }
} }
// clear any data allocated by post-process steps // clear any data allocated by post-process steps
pimpl->mPPShared->Clean(); pimpl->mPPShared->Clean();
DefaultLogger::get()->info( "Leaving customized post processing pipeline" ); ASSIMP_LOG_INFO( "Leaving customized post processing pipeline" );
ASSIMP_END_EXCEPTION_REGION( const aiScene* ); ASSIMP_END_EXCEPTION_REGION( const aiScene* );
@ -903,7 +893,7 @@ const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess
// Helper function to check whether an extension is supported by ASSIMP // Helper function to check whether an extension is supported by ASSIMP
bool Importer::IsExtensionSupported(const char* szExtension) const bool Importer::IsExtensionSupported(const char* szExtension) const
{ {
return NULL != GetImporter(szExtension); return nullptr != GetImporter(szExtension);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

20
code/Importer/IFC/STEPFileReader.cpp
View File

@ -126,7 +126,7 @@ STEP::DB* STEP::ReadFileHeader(std::shared_ptr<IOStream> stream)
// XXX need support for multiple schemas? // XXX need support for multiple schemas?
if (list->GetSize() > 1) { if (list->GetSize() > 1) {
DefaultLogger::get()->warn(AddLineNumber("multiple schemas currently not supported",line)); ASSIMP_LOG_WARN(AddLineNumber("multiple schemas currently not supported",line));
} }
const EXPRESS::STRING* string( nullptr ); const EXPRESS::STRING* string( nullptr );
if (!list->GetSize() || !(string=dynamic_cast<const EXPRESS::STRING*>( (*list)[0].get() ))) { if (!list->GetSize() || !(string=dynamic_cast<const EXPRESS::STRING*>( (*list)[0].get() ))) {
@ -192,7 +192,7 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
// LineSplitter already ignores empty lines // LineSplitter already ignores empty lines
ai_assert(s.length()); ai_assert(s.length());
if (s[0] != '#') { if (s[0] != '#') {
DefaultLogger::get()->warn(AddLineNumber("expected token \'#\'",line)); ASSIMP_LOG_WARN(AddLineNumber("expected token \'#\'",line));
++splitter; ++splitter;
continue; continue;
} }
@ -202,14 +202,14 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
// --- // ---
const std::string::size_type n0 = s.find_first_of('='); const std::string::size_type n0 = s.find_first_of('=');
if (n0 == std::string::npos) { if (n0 == std::string::npos) {
DefaultLogger::get()->warn(AddLineNumber("expected token \'=\'",line)); ASSIMP_LOG_WARN(AddLineNumber("expected token \'=\'",line));
++splitter; ++splitter;
continue; continue;
} }
const uint64_t id = strtoul10_64(s.substr(1,n0-1).c_str()); const uint64_t id = strtoul10_64(s.substr(1,n0-1).c_str());
if (!id) { if (!id) {
DefaultLogger::get()->warn(AddLineNumber("expected positive, numeric entity id",line)); ASSIMP_LOG_WARN(AddLineNumber("expected positive, numeric entity id",line));
++splitter; ++splitter;
continue; continue;
} }
@ -236,7 +236,7 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
} }
if(!ok) { if(!ok) {
DefaultLogger::get()->warn(AddLineNumber("expected token \'(\'",line)); ASSIMP_LOG_WARN(AddLineNumber("expected token \'(\'",line));
continue; continue;
} }
} }
@ -263,13 +263,13 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
} }
} }
if(!ok) { if(!ok) {
DefaultLogger::get()->warn(AddLineNumber("expected token \')\'",line)); ASSIMP_LOG_WARN(AddLineNumber("expected token \')\'",line));
continue; continue;
} }
} }
if (map.find(id) != map.end()) { if (map.find(id) != map.end()) {
DefaultLogger::get()->warn(AddLineNumber((Formatter::format(),"an object with the id #",id," already exists"),line)); ASSIMP_LOG_WARN(AddLineNumber((Formatter::format(),"an object with the id #",id," already exists"),line));
} }
std::string::size_type ns = n0; std::string::size_type ns = n0;
@ -292,11 +292,11 @@ void STEP::ReadFile(DB& db,const EXPRESS::ConversionSchema& scheme,
} }
if (!splitter) { if (!splitter) {
DefaultLogger::get()->warn("STEP: ignoring unexpected EOF"); ASSIMP_LOG_WARN("STEP: ignoring unexpected EOF");
} }
if ( !DefaultLogger::isNullLogger()){ if ( !DefaultLogger::isNullLogger()){
DefaultLogger::get()->debug((Formatter::format(),"STEP: got ",map.size()," object records with ", ASSIMP_LOG_DEBUG((Formatter::format(),"STEP: got ",map.size()," object records with ",
db.GetRefs().size()," inverse index entries")); db.GetRefs().size()," inverse index entries"));
} }
} }
@ -392,7 +392,7 @@ std::shared_ptr<const EXPRESS::DataType> EXPRESS::DataType::Parse(const char*& i
std::string stemp = std::string(start, static_cast<size_t>(cur - start)); std::string stemp = std::string(start, static_cast<size_t>(cur - start));
if(!StringToUTF8(stemp)) { if(!StringToUTF8(stemp)) {
// TODO: route this to a correct logger with line numbers etc., better error messages // TODO: route this to a correct logger with line numbers etc., better error messages
DefaultLogger::get()->error("an error occurred reading escape sequences in ASCII text"); ASSIMP_LOG_ERROR("an error occurred reading escape sequences in ASCII text");
} }
return std::make_shared<EXPRESS::STRING>(stemp); return std::make_shared<EXPRESS::STRING>(stemp);

22
code/ImproveCacheLocality.cpp
View File

@ -95,11 +95,11 @@ void ImproveCacheLocalityProcess::SetupProperties(const Importer* pImp)
void ImproveCacheLocalityProcess::Execute( aiScene* pScene) void ImproveCacheLocalityProcess::Execute( aiScene* pScene)
{ {
if (!pScene->mNumMeshes) { if (!pScene->mNumMeshes) {
DefaultLogger::get()->debug("ImproveCacheLocalityProcess skipped; there are no meshes"); ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess skipped; there are no meshes");
return; return;
} }
DefaultLogger::get()->debug("ImproveCacheLocalityProcess begin"); ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess begin");
float out = 0.f; float out = 0.f;
unsigned int numf = 0, numm = 0; unsigned int numf = 0, numm = 0;
@ -112,12 +112,8 @@ void ImproveCacheLocalityProcess::Execute( aiScene* pScene)
} }
} }
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
char szBuff[128]; // should be sufficiently large in every case ASSIMP_LOG_INFO_F("Cache relevant are ", numm, " meshes (", numf," faces). Average output ACMR is ", out / numf );
ai_snprintf(szBuff,128,"Cache relevant are %u meshes (%u faces). Average output ACMR is %f", ASSIMP_LOG_DEBUG("ImproveCacheLocalityProcess finished. ");
numm,numf,out/numf);
DefaultLogger::get()->info(szBuff);
DefaultLogger::get()->debug("ImproveCacheLocalityProcess finished. ");
} }
} }
@ -135,7 +131,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh
return 0.f; return 0.f;
if (pMesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE) { if (pMesh->mPrimitiveTypes != aiPrimitiveType_TRIANGLE) {
DefaultLogger::get()->error("This algorithm works on triangle meshes only"); ASSIMP_LOG_ERROR("This algorithm works on triangle meshes only");
return 0.f; return 0.f;
} }
@ -186,7 +182,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh
// mesh, otherwise this value would normally be at least minimally // mesh, otherwise this value would normally be at least minimally
// smaller than 3.0 ... // smaller than 3.0 ...
ai_snprintf(szBuff,128,"Mesh %u: Not suitable for vcache optimization",meshNum); ai_snprintf(szBuff,128,"Mesh %u: Not suitable for vcache optimization",meshNum);
DefaultLogger::get()->warn(szBuff); ASSIMP_LOG_WARN(szBuff);
return 0.f; return 0.f;
} }
} }
@ -364,11 +360,7 @@ float ImproveCacheLocalityProcess::ProcessMesh( aiMesh* pMesh, unsigned int mesh
// very intense verbose logging ... prepare for much text if there are many meshes // very intense verbose logging ... prepare for much text if there are many meshes
if ( DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) { if ( DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) {
char szBuff[128]; // should be sufficiently large in every case ASSIMP_LOG_DEBUG_F("Mesh %u | ACMR in: ", meshNum, " out: ", fACMR, " | ~", fACMR2, ((fACMR - fACMR2) / fACMR) * 100.f);
ai_snprintf(szBuff,128,"Mesh %u | ACMR in: %f out: %f | ~%.1f%%",meshNum,fACMR,fACMR2,
((fACMR - fACMR2) / fACMR) * 100.f);
DefaultLogger::get()->debug(szBuff);
} }
fACMR2 *= pMesh->mNumFaces; fACMR2 *= pMesh->mNumFaces;

30
code/JoinVerticesProcess.cpp
View File

@ -79,7 +79,7 @@ bool JoinVerticesProcess::IsActive( unsigned int pFlags) const
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void JoinVerticesProcess::Execute( aiScene* pScene) void JoinVerticesProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("JoinVerticesProcess begin"); ASSIMP_LOG_DEBUG("JoinVerticesProcess begin");
// get the total number of vertices BEFORE the step is executed // get the total number of vertices BEFORE the step is executed
int iNumOldVertices = 0; int iNumOldVertices = 0;
@ -95,19 +95,13 @@ void JoinVerticesProcess::Execute( aiScene* pScene)
iNumVertices += ProcessMesh( pScene->mMeshes[a],a); iNumVertices += ProcessMesh( pScene->mMeshes[a],a);
// if logging is active, print detailed statistics // if logging is active, print detailed statistics
if (!DefaultLogger::isNullLogger()) if (!DefaultLogger::isNullLogger()) {
{ if (iNumOldVertices == iNumVertices) {
if (iNumOldVertices == iNumVertices) ASSIMP_LOG_DEBUG("JoinVerticesProcess finished ");
{ } else {
DefaultLogger::get()->debug("JoinVerticesProcess finished "); ASSIMP_LOG_INFO_F("JoinVerticesProcess finished | Verts in: ", iNumOldVertices,
} else " out: ", iNumVertices, " | ~",
{ ((iNumOldVertices - iNumVertices) / (float)iNumOldVertices) * 100.f );
char szBuff[128]; // should be sufficiently large in every case
::ai_snprintf(szBuff,128,"JoinVerticesProcess finished | Verts in: %i out: %i | ~%.1f%%",
iNumOldVertices,
iNumVertices,
((iNumOldVertices - iNumVertices) / (float)iNumOldVertices) * 100.f);
DefaultLogger::get()->info(szBuff);
} }
} }
@ -274,7 +268,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
} }
if (!DefaultLogger::isNullLogger() && DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) { if (!DefaultLogger::isNullLogger() && DefaultLogger::get()->getLogSeverity() == Logger::VERBOSE) {
DefaultLogger::get()->debug((Formatter::format(), ASSIMP_LOG_DEBUG_F(
"Mesh ",meshIndex, "Mesh ",meshIndex,
" (", " (",
(pMesh->mName.length ? pMesh->mName.data : "unnamed"), (pMesh->mName.length ? pMesh->mName.data : "unnamed"),
@ -284,7 +278,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
" | ~", " | ~",
((pMesh->mNumVertices - uniqueVertices.size()) / (float)pMesh->mNumVertices) * 100.f, ((pMesh->mNumVertices - uniqueVertices.size()) / (float)pMesh->mNumVertices) * 100.f,
"%" "%"
)); );
} }
// replace vertex data with the unique data sets // replace vertex data with the unique data sets
@ -375,7 +369,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
} }
} }
} else { } else {
DefaultLogger::get()->error( "X-Export: aiBone shall contain weights, but pointer to them is NULL." ); ASSIMP_LOG_ERROR( "X-Export: aiBone shall contain weights, but pointer to them is NULL." );
} }
if (newWeights.size() > 0) { if (newWeights.size() > 0) {
@ -409,7 +403,7 @@ int JoinVerticesProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
} }
--a; --a;
DefaultLogger::get()->warn("Removing bone -> no weights remaining"); ASSIMP_LOG_WARN("Removing bone -> no weights remaining");
} }
} }
return pMesh->mNumVertices; return pMesh->mNumVertices;

36
code/LWOBLoader.cpp
View File

@ -74,7 +74,7 @@ void LWOImporter::LoadLWOBFile()
case AI_LWO_PNTS: case AI_LWO_PNTS:
{ {
if (!mCurLayer->mTempPoints.empty()) if (!mCurLayer->mTempPoints.empty())
DefaultLogger::get()->warn("LWO: PNTS chunk encountered twice"); ASSIMP_LOG_WARN("LWO: PNTS chunk encountered twice");
else LoadLWOPoints(head.length); else LoadLWOPoints(head.length);
break; break;
} }
@ -83,7 +83,7 @@ void LWOImporter::LoadLWOBFile()
{ {
if (!mCurLayer->mFaces.empty()) if (!mCurLayer->mFaces.empty())
DefaultLogger::get()->warn("LWO: POLS chunk encountered twice"); ASSIMP_LOG_WARN("LWO: POLS chunk encountered twice");
else LoadLWOBPolygons(head.length); else LoadLWOBPolygons(head.length);
break; break;
} }
@ -91,7 +91,7 @@ void LWOImporter::LoadLWOBFile()
case AI_LWO_SRFS: case AI_LWO_SRFS:
{ {
if (!mTags->empty()) if (!mTags->empty())
DefaultLogger::get()->warn("LWO: SRFS chunk encountered twice"); ASSIMP_LOG_WARN("LWO: SRFS chunk encountered twice");
else LoadLWOTags(head.length); else LoadLWOTags(head.length);
break; break;
} }
@ -183,20 +183,20 @@ void LWOImporter::CopyFaceIndicesLWOB(FaceList::iterator& it,
break; break;
} }
face.mIndices = new unsigned int[face.mNumIndices]; face.mIndices = new unsigned int[face.mNumIndices];
for (unsigned int i = 0; i < face.mNumIndices;++i) for (unsigned int i = 0; i < face.mNumIndices;++i) {
{
unsigned int & mi = face.mIndices[i]; unsigned int & mi = face.mIndices[i];
uint16_t index; uint16_t index;
::memcpy(&index, cursor++, 2); ::memcpy(&index, cursor++, 2);
mi = index; mi = index;
if (mi > mCurLayer->mTempPoints.size()) if (mi > mCurLayer->mTempPoints.size())
{ {
DefaultLogger::get()->warn("LWOB: face index is out of range"); ASSIMP_LOG_WARN("LWOB: face index is out of range");
mi = (unsigned int)mCurLayer->mTempPoints.size()-1; mi = (unsigned int)mCurLayer->mTempPoints.size()-1;
} }
} }
} else {
ASSIMP_LOG_WARN("LWOB: Face has 0 indices");
} }
else DefaultLogger::get()->warn("LWOB: Face has 0 indices");
int16_t surface; int16_t surface;
::memcpy(&surface, cursor++, 2); ::memcpy(&surface, cursor++, 2);
if (surface < 0) if (surface < 0)
@ -242,7 +242,7 @@ LWO::Texture* LWOImporter::SetupNewTextureLWOB(LWO::TextureList& list,unsigned i
else else
{ {
// procedural or gradient, not supported // procedural or gradient, not supported
DefaultLogger::get()->error("LWOB: Unsupported legacy texture: " + type); ASSIMP_LOG_ERROR_F("LWOB: Unsupported legacy texture: ", type);
} }
return tex; return tex;
@ -273,7 +273,7 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
* how much storage is actually left and work with this value from now on. * how much storage is actually left and work with this value from now on.
*/ */
if (mFileBuffer + head.length > end) { if (mFileBuffer + head.length > end) {
DefaultLogger::get()->error("LWOB: Invalid surface chunk length. Trying to continue."); ASSIMP_LOG_ERROR("LWOB: Invalid surface chunk length. Trying to continue.");
head.length = (uint16_t) (end - mFileBuffer); head.length = (uint16_t) (end - mFileBuffer);
} }
@ -381,8 +381,9 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
{ {
if (pTex) { if (pTex) {
GetS0(pTex->mFileName,head.length); GetS0(pTex->mFileName,head.length);
} else {
ASSIMP_LOG_WARN("LWOB: Unexpected TIMG chunk");
} }
else DefaultLogger::get()->warn("LWOB: Unexpected TIMG chunk");
break; break;
} }
// texture strength // texture strength
@ -391,8 +392,9 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TVAL,1); AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TVAL,1);
if (pTex) { if (pTex) {
pTex->mStrength = (float)GetU1()/ 255.f; pTex->mStrength = (float)GetU1()/ 255.f;
} else {
ASSIMP_LOG_ERROR("LWOB: Unexpected TVAL chunk");
} }
else DefaultLogger::get()->warn("LWOB: Unexpected TVAL chunk");
break; break;
} }
// texture flags // texture flags
@ -400,8 +402,7 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
{ {
AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TFLG,2); AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,TFLG,2);
if (pTex) if (nullptr != pTex) {
{
const uint16_t s = GetU2(); const uint16_t s = GetU2();
if (s & 1) if (s & 1)
pTex->majorAxis = LWO::Texture::AXIS_X; pTex->majorAxis = LWO::Texture::AXIS_X;
@ -410,10 +411,13 @@ void LWOImporter::LoadLWOBSurface(unsigned int size)
else if (s & 4) else if (s & 4)
pTex->majorAxis = LWO::Texture::AXIS_Z; pTex->majorAxis = LWO::Texture::AXIS_Z;
if (s & 16) if (s & 16) {
DefaultLogger::get()->warn("LWOB: Ignoring \'negate\' flag on texture"); ASSIMP_LOG_WARN("LWOB: Ignoring \'negate\' flag on texture");
}
}
else {
ASSIMP_LOG_WARN("LWOB: Unexpected TFLG chunk");
} }
else DefaultLogger::get()->warn("LWOB: Unexpected TFLG chunk");
break; break;
} }
} }

79
code/LWOLoader.cpp
View File

@ -188,7 +188,7 @@ void LWOImporter::InternReadFile( const std::string& pFile,
// old lightwave file format (prior to v6) // old lightwave file format (prior to v6)
if (AI_LWO_FOURCC_LWOB == fileType) { if (AI_LWO_FOURCC_LWOB == fileType) {
DefaultLogger::get()->info("LWO file format: LWOB (<= LightWave 5.5)"); ASSIMP_LOG_INFO("LWO file format: LWOB (<= LightWave 5.5)");
mIsLWO2 = false; mIsLWO2 = false;
mIsLXOB = false; mIsLXOB = false;
@ -197,12 +197,12 @@ void LWOImporter::InternReadFile( const std::string& pFile,
// New lightwave format // New lightwave format
else if (AI_LWO_FOURCC_LWO2 == fileType) { else if (AI_LWO_FOURCC_LWO2 == fileType) {
mIsLXOB = false; mIsLXOB = false;
DefaultLogger::get()->info("LWO file format: LWO2 (>= LightWave 6)"); ASSIMP_LOG_INFO("LWO file format: LWO2 (>= LightWave 6)");
} }
// MODO file format // MODO file format
else if (AI_LWO_FOURCC_LXOB == fileType) { else if (AI_LWO_FOURCC_LXOB == fileType) {
mIsLXOB = true; mIsLXOB = true;
DefaultLogger::get()->info("LWO file format: LXOB (Modo)"); ASSIMP_LOG_INFO("LWO file format: LXOB (Modo)");
} }
// we don't know this format // we don't know this format
else else
@ -271,7 +271,7 @@ void LWOImporter::InternReadFile( const std::string& pFile,
unsigned int idx = (*it).surfaceIndex; unsigned int idx = (*it).surfaceIndex;
if (idx >= mTags->size()) if (idx >= mTags->size())
{ {
DefaultLogger::get()->warn("LWO: Invalid face surface index"); ASSIMP_LOG_WARN("LWO: Invalid face surface index");
idx = UINT_MAX; idx = UINT_MAX;
} }
if(UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) { if(UINT_MAX == idx || UINT_MAX == (idx = _mMapping[idx])) {
@ -423,7 +423,9 @@ void LWOImporter::InternReadFile( const std::string& pFile,
// So we use a separate implementation. // So we use a separate implementation.
ComputeNormals(mesh,smoothingGroups,_mSurfaces[i]); ComputeNormals(mesh,smoothingGroups,_mSurfaces[i]);
} }
else DefaultLogger::get()->debug("LWO2: No need to compute normals, they're already there"); else {
ASSIMP_LOG_DEBUG("LWO2: No need to compute normals, they're already there");
}
++p; ++p;
} }
} }
@ -686,13 +688,13 @@ void LWOImporter::ResolveClips()
if (Clip::REF == clip.type) { if (Clip::REF == clip.type) {
if (clip.clipRef >= mClips.size()) { if (clip.clipRef >= mClips.size()) {
DefaultLogger::get()->error("LWO2: Clip referrer index is out of range"); ASSIMP_LOG_ERROR("LWO2: Clip referrer index is out of range");
clip.clipRef = 0; clip.clipRef = 0;
} }
Clip& dest = mClips[clip.clipRef]; Clip& dest = mClips[clip.clipRef];
if (Clip::REF == dest.type) { if (Clip::REF == dest.type) {
DefaultLogger::get()->error("LWO2: Clip references another clip reference"); ASSIMP_LOG_ERROR("LWO2: Clip references another clip reference");
clip.type = Clip::UNSUPPORTED; clip.type = Clip::UNSUPPORTED;
} }
@ -711,7 +713,7 @@ void LWOImporter::AdjustTexturePath(std::string& out)
if (!mIsLWO2 && ::strstr(out.c_str(), "(sequence)")) { if (!mIsLWO2 && ::strstr(out.c_str(), "(sequence)")) {
// remove the (sequence) and append 000 // remove the (sequence) and append 000
DefaultLogger::get()->info("LWOB: Sequence of animated texture found. It will be ignored"); ASSIMP_LOG_INFO("LWOB: Sequence of animated texture found. It will be ignored");
out = out.substr(0,out.length()-10) + "000"; out = out.substr(0,out.length()-10) + "000";
} }
@ -786,10 +788,10 @@ void LWOImporter::LoadLWO2Polygons(unsigned int length)
{ {
// read unsupported stuff too (although we won't process it) // read unsupported stuff too (although we won't process it)
case AI_LWO_MBAL: case AI_LWO_MBAL:
DefaultLogger::get()->warn("LWO2: Encountered unsupported primitive chunk (METABALL)"); ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (METABALL)");
break; break;
case AI_LWO_CURV: case AI_LWO_CURV:
DefaultLogger::get()->warn("LWO2: Encountered unsupported primitive chunk (SPLINE)");; ASSIMP_LOG_WARN("LWO2: Encountered unsupported primitive chunk (SPLINE)");;
break; break;
// These are ok with no restrictions // These are ok with no restrictions
@ -801,7 +803,7 @@ void LWOImporter::LoadLWO2Polygons(unsigned int length)
default: default:
// hm!? wtf is this? ok ... // hm!? wtf is this? ok ...
DefaultLogger::get()->error("LWO2: Ignoring unknown polygon type."); ASSIMP_LOG_ERROR("LWO2: Ignoring unknown polygon type.");
break; break;
} }
@ -864,7 +866,7 @@ void LWOImporter::CopyFaceIndicesLWO2(FaceList::iterator& it,
face.mIndices[i] = ReadVSizedIntLWO2((uint8_t*&)cursor) + mCurLayer->mPointIDXOfs; face.mIndices[i] = ReadVSizedIntLWO2((uint8_t*&)cursor) + mCurLayer->mPointIDXOfs;
if(face.mIndices[i] > mCurLayer->mTempPoints.size()) if(face.mIndices[i] > mCurLayer->mTempPoints.size())
{ {
DefaultLogger::get()->warn("LWO2: Failure evaluating face record, index is out of range"); ASSIMP_LOG_WARN("LWO2: Failure evaluating face record, index is out of range");
face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size()-1; face.mIndices[i] = (unsigned int)mCurLayer->mTempPoints.size()-1;
} }
} }
@ -891,7 +893,7 @@ void LWOImporter::LoadLWO2PolygonTags(unsigned int length)
unsigned int j = GetU2(); unsigned int j = GetU2();
if (i >= mCurLayer->mFaces.size()) { if (i >= mCurLayer->mFaces.size()) {
DefaultLogger::get()->warn("LWO2: face index in PTAG is out of range"); ASSIMP_LOG_WARN("LWO2: face index in PTAG is out of range");
continue; continue;
} }
@ -914,7 +916,7 @@ VMapEntry* FindEntry(std::vector< T >& list,const std::string& name, bool perPol
for (auto & elem : list) { for (auto & elem : list) {
if (elem.name == name) { if (elem.name == name) {
if (!perPoly) { if (!perPoly) {
DefaultLogger::get()->warn("LWO2: Found two VMAP sections with equal names"); ASSIMP_LOG_WARN("LWO2: Found two VMAP sections with equal names");
} }
return &elem; return &elem;
} }
@ -999,7 +1001,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
{ {
case AI_LWO_TXUV: case AI_LWO_TXUV:
if (dims != 2) { if (dims != 2) {
DefaultLogger::get()->warn("LWO2: Skipping UV channel \'" ASSIMP_LOG_WARN("LWO2: Skipping UV channel \'"
+ name + "\' with !2 components"); + name + "\' with !2 components");
return; return;
} }
@ -1008,7 +1010,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
case AI_LWO_WGHT: case AI_LWO_WGHT:
case AI_LWO_MNVW: case AI_LWO_MNVW:
if (dims != 1) { if (dims != 1) {
DefaultLogger::get()->warn("LWO2: Skipping Weight Channel \'" ASSIMP_LOG_WARN("LWO2: Skipping Weight Channel \'"
+ name + "\' with !1 components"); + name + "\' with !1 components");
return; return;
} }
@ -1018,7 +1020,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
case AI_LWO_RGB: case AI_LWO_RGB:
case AI_LWO_RGBA: case AI_LWO_RGBA:
if (dims != 3 && dims != 4) { if (dims != 3 && dims != 4) {
DefaultLogger::get()->warn("LWO2: Skipping Color Map \'" ASSIMP_LOG_WARN("LWO2: Skipping Color Map \'"
+ name + "\' with a dimension > 4 or < 3"); + name + "\' with a dimension > 4 or < 3");
return; return;
} }
@ -1033,7 +1035,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length()) if (name != "vert_normals" || dims != 3 || mCurLayer->mNormals.name.length())
return; return;
DefaultLogger::get()->info("Processing non-standard extension: MODO VMAP.NORM.vert_normals"); ASSIMP_LOG_INFO("Processing non-standard extension: MODO VMAP.NORM.vert_normals");
mCurLayer->mNormals.name = name; mCurLayer->mNormals.name = name;
base = & mCurLayer->mNormals; base = & mCurLayer->mNormals;
@ -1048,7 +1050,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
if (name == "APS.Level") { if (name == "APS.Level") {
// XXX handle this (seems to be subdivision-related). // XXX handle this (seems to be subdivision-related).
} }
DefaultLogger::get()->warn("LWO2: Skipping unknown VMAP/VMAD channel \'" + name + "\'"); ASSIMP_LOG_WARN_F("LWO2: Skipping unknown VMAP/VMAD channel \'", name, "\'");
return; return;
}; };
base->Allocate((unsigned int)mCurLayer->mTempPoints.size()); base->Allocate((unsigned int)mCurLayer->mTempPoints.size());
@ -1068,7 +1070,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs; unsigned int idx = ReadVSizedIntLWO2(mFileBuffer) + mCurLayer->mPointIDXOfs;
if (idx >= numPoints) { if (idx >= numPoints) {
DefaultLogger::get()->warn("LWO2: Failure evaluating VMAP/VMAD entry \'" + name + "\', vertex index is out of range"); ASSIMP_LOG_WARN_F("LWO2: Failure evaluating VMAP/VMAD entry \'", name, "\', vertex index is out of range");
mFileBuffer += base->dims<<2u; mFileBuffer += base->dims<<2u;
continue; continue;
} }
@ -1078,7 +1080,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
// we have already a VMAP entry for this vertex - thus // we have already a VMAP entry for this vertex - thus
// we need to duplicate the corresponding polygon. // we need to duplicate the corresponding polygon.
if (polyIdx >= numFaces) { if (polyIdx >= numFaces) {
DefaultLogger::get()->warn("LWO2: Failure evaluating VMAD entry \'" + name + "\', polygon index is out of range"); ASSIMP_LOG_WARN_F("LWO2: Failure evaluating VMAD entry \'", name, "\', polygon index is out of range");
mFileBuffer += base->dims<<2u; mFileBuffer += base->dims<<2u;
continue; continue;
} }
@ -1119,7 +1121,7 @@ void LWOImporter::LoadLWO2VertexMap(unsigned int length, bool perPoly)
CreateNewEntry(mCurLayer->mNormals, srcIdx ); CreateNewEntry(mCurLayer->mNormals, srcIdx );
} }
if (!had) { if (!had) {
DefaultLogger::get()->warn("LWO2: Failure evaluating VMAD entry \'" + name + "\', vertex index wasn't found in that polygon"); ASSIMP_LOG_WARN_F("LWO2: Failure evaluating VMAD entry \'", name, "\', vertex index wasn't found in that polygon");
ai_assert(had); ai_assert(had);
} }
} }
@ -1180,11 +1182,11 @@ void LWOImporter::LoadLWO2Clip(unsigned int length)
break; break;
case AI_LWO_STCC: case AI_LWO_STCC:
DefaultLogger::get()->warn("LWO2: Color shifted images are not supported"); ASSIMP_LOG_WARN("LWO2: Color shifted images are not supported");
break; break;
case AI_LWO_ANIM: case AI_LWO_ANIM:
DefaultLogger::get()->warn("LWO2: Animated textures are not supported"); ASSIMP_LOG_WARN("LWO2: Animated textures are not supported");
break; break;
case AI_LWO_XREF: case AI_LWO_XREF:
@ -1201,7 +1203,7 @@ void LWOImporter::LoadLWO2Clip(unsigned int length)
break; break;
default: default:
DefaultLogger::get()->warn("LWO2: Encountered unknown CLIP subchunk"); ASSIMP_LOG_WARN("LWO2: Encountered unknown CLIP sub-chunk");
} }
} }
@ -1282,7 +1284,7 @@ void LWOImporter::LoadLWO2Envelope(unsigned int length)
{ {
AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPAN,4); AI_LWO_VALIDATE_CHUNK_LENGTH(head.length,SPAN,4);
if (envelope.keys.size()<2) if (envelope.keys.size()<2)
DefaultLogger::get()->warn("LWO2: Unexpected SPAN chunk"); ASSIMP_LOG_WARN("LWO2: Unexpected SPAN chunk");
else { else {
LWO::Key& key = envelope.keys.back(); LWO::Key& key = envelope.keys.back();
switch (GetU4()) switch (GetU4())
@ -1300,7 +1302,7 @@ void LWOImporter::LoadLWO2Envelope(unsigned int length)
case AI_LWO_BEZ2: case AI_LWO_BEZ2:
key.inter = LWO::IT_BEZ2;break; key.inter = LWO::IT_BEZ2;break;
default: default:
DefaultLogger::get()->warn("LWO2: Unknown interval interpolation mode"); ASSIMP_LOG_WARN("LWO2: Unknown interval interpolation mode");
}; };
// todo ... read params // todo ... read params
@ -1309,7 +1311,8 @@ void LWOImporter::LoadLWO2Envelope(unsigned int length)
} }
default: default:
DefaultLogger::get()->warn("LWO2: Encountered unknown ENVL subchunk"); ASSIMP_LOG_WARN("LWO2: Encountered unknown ENVL subchunk");
break;
} }
// regardless how much we did actually read, go to the next chunk // regardless how much we did actually read, go to the next chunk
mFileBuffer = next; mFileBuffer = next;
@ -1408,7 +1411,7 @@ void LWOImporter::LoadLWO2File()
case AI_LWO_VMAD: case AI_LWO_VMAD:
if (mCurLayer->mFaces.empty()) if (mCurLayer->mFaces.empty())
{ {
DefaultLogger::get()->warn("LWO2: Unexpected VMAD chunk"); ASSIMP_LOG_WARN("LWO2: Unexpected VMAD chunk");
break; break;
} }
// --- intentionally no break here // --- intentionally no break here
@ -1418,7 +1421,7 @@ void LWOImporter::LoadLWO2File()
break; break;
if (mCurLayer->mTempPoints.empty()) if (mCurLayer->mTempPoints.empty())
DefaultLogger::get()->warn("LWO2: Unexpected VMAP chunk"); ASSIMP_LOG_WARN("LWO2: Unexpected VMAP chunk");
else LoadLWO2VertexMap(head.length,head.type == AI_LWO_VMAD); else LoadLWO2VertexMap(head.length,head.type == AI_LWO_VMAD);
break; break;
} }
@ -1439,17 +1442,21 @@ void LWOImporter::LoadLWO2File()
if (skip) if (skip)
break; break;
if (mCurLayer->mFaces.empty()) if (mCurLayer->mFaces.empty()) {
DefaultLogger::get()->warn("LWO2: Unexpected PTAG"); ASSIMP_LOG_WARN("LWO2: Unexpected PTAG");
else LoadLWO2PolygonTags(head.length); } else {
LoadLWO2PolygonTags(head.length);
}
break; break;
} }
// list of tags // list of tags
case AI_LWO_TAGS: case AI_LWO_TAGS:
{ {
if (!mTags->empty()) if (!mTags->empty()) {
DefaultLogger::get()->warn("LWO2: SRFS chunk encountered twice"); ASSIMP_LOG_WARN("LWO2: SRFS chunk encountered twice");
else LoadLWOTags(head.length); } else {
LoadLWOTags(head.length);
}
break; break;
} }

2
code/LWOLoader.h
View File

@ -473,7 +473,7 @@ inline void LWOImporter::GetS0(std::string& out,unsigned int max)
{ {
if (++iCursor > max) if (++iCursor > max)
{ {
DefaultLogger::get()->warn("LWO: Invalid file, string is is too long"); ASSIMP_LOG_WARN("LWO: Invalid file, string is is too long");
break; break;
} }
++mFileBuffer; ++mFileBuffer;

40
code/LWOMaterial.cpp
View File

@ -74,7 +74,7 @@ inline aiTextureMapMode GetMapMode(LWO::Texture::Wrap in)
return aiTextureMapMode_Mirror; return aiTextureMapMode_Mirror;
case LWO::Texture::RESET: case LWO::Texture::RESET:
DefaultLogger::get()->warn("LWO2: Unsupported texture map mode: RESET"); ASSIMP_LOG_WARN("LWO2: Unsupported texture map mode: RESET");
// fall though here // fall though here
case LWO::Texture::EDGE: case LWO::Texture::EDGE:
@ -117,7 +117,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
mapping = aiTextureMapping_BOX; mapping = aiTextureMapping_BOX;
break; break;
case LWO::Texture::FrontProjection: case LWO::Texture::FrontProjection:
DefaultLogger::get()->error("LWO2: Unsupported texture mapping: FrontProjection"); ASSIMP_LOG_ERROR("LWO2: Unsupported texture mapping: FrontProjection");
mapping = aiTextureMapping_OTHER; mapping = aiTextureMapping_OTHER;
break; break;
case LWO::Texture::UV: case LWO::Texture::UV:
@ -164,7 +164,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
static_assert(sizeof(aiUVTransform)/sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5"); static_assert(sizeof(aiUVTransform)/sizeof(ai_real) == 5, "sizeof(aiUVTransform)/sizeof(ai_real) == 5");
pcMat->AddProperty(&trafo,1,AI_MATKEY_UVTRANSFORM(type,cur)); pcMat->AddProperty(&trafo,1,AI_MATKEY_UVTRANSFORM(type,cur));
} }
DefaultLogger::get()->debug("LWO2: Setting up non-UV mapping"); ASSIMP_LOG_DEBUG("LWO2: Setting up non-UV mapping");
} }
// The older LWOB format does not use indirect references to clips. // The older LWOB format does not use indirect references to clips.
@ -181,7 +181,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
} }
if (candidate == end) { if (candidate == end) {
DefaultLogger::get()->error("LWO2: Clip index is out of bounds"); ASSIMP_LOG_ERROR("LWO2: Clip index is out of bounds");
temp = 0; temp = 0;
// fixme: apparently some LWO files shipping with Doom3 don't // fixme: apparently some LWO files shipping with Doom3 don't
@ -194,7 +194,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
} }
else { else {
if (Clip::UNSUPPORTED == (*candidate).type) { if (Clip::UNSUPPORTED == (*candidate).type) {
DefaultLogger::get()->error("LWO2: Clip type is not supported"); ASSIMP_LOG_ERROR("LWO2: Clip type is not supported");
continue; continue;
} }
AdjustTexturePath((*candidate).path); AdjustTexturePath((*candidate).path);
@ -212,7 +212,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
{ {
std::string ss = texture.mFileName; std::string ss = texture.mFileName;
if (!ss.length()) { if (!ss.length()) {
DefaultLogger::get()->error("LWOB: Empty file name"); ASSIMP_LOG_WARN("LWOB: Empty file name");
continue; continue;
} }
AdjustTexturePath(ss); AdjustTexturePath(ss);
@ -246,7 +246,7 @@ bool LWOImporter::HandleTextures(aiMaterial* pcMat, const TextureList& in, aiTex
default: default:
temp = (unsigned int)aiTextureOp_Multiply; temp = (unsigned int)aiTextureOp_Multiply;
DefaultLogger::get()->warn("LWO2: Unsupported texture blend mode: alpha or displacement"); ASSIMP_LOG_WARN("LWO2: Unsupported texture blend mode: alpha or displacement");
} }
// Setup texture operation // Setup texture operation
@ -347,20 +347,20 @@ void LWOImporter::ConvertMaterial(const LWO::Surface& surf,aiMaterial* pcMat)
// the surface and search for a name which we know ... // the surface and search for a name which we know ...
for (const auto &shader : surf.mShaders) { for (const auto &shader : surf.mShaders) {
if (shader.functionName == "LW_SuperCelShader" || shader.functionName == "AH_CelShader") { if (shader.functionName == "LW_SuperCelShader" || shader.functionName == "AH_CelShader") {
DefaultLogger::get()->info("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon"); ASSIMP_LOG_INFO("LWO2: Mapping LW_SuperCelShader/AH_CelShader to aiShadingMode_Toon");
m = aiShadingMode_Toon; m = aiShadingMode_Toon;
break; break;
} }
else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel") { else if (shader.functionName == "LW_RealFresnel" || shader.functionName == "LW_FastFresnel") {
DefaultLogger::get()->info("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel"); ASSIMP_LOG_INFO("LWO2: Mapping LW_RealFresnel/LW_FastFresnel to aiShadingMode_Fresnel");
m = aiShadingMode_Fresnel; m = aiShadingMode_Fresnel;
break; break;
} }
else else
{ {
DefaultLogger::get()->warn("LWO2: Unknown surface shader: " + shader.functionName); ASSIMP_LOG_WARN_F("LWO2: Unknown surface shader: ", shader.functionName);
} }
} }
if (surf.mMaximumSmoothAngle <= 0.0) if (surf.mMaximumSmoothAngle <= 0.0)
@ -398,7 +398,7 @@ char LWOImporter::FindUVChannels(LWO::TextureList& list,
} }
else { else {
// channel mismatch. need to duplicate the material. // channel mismatch. need to duplicate the material.
DefaultLogger::get()->warn("LWO: Channel mismatch, would need to duplicate surface [design bug]"); ASSIMP_LOG_WARN("LWO: Channel mismatch, would need to duplicate surface [design bug]");
// TODO // TODO
} }
@ -429,7 +429,7 @@ void LWOImporter::FindUVChannels(LWO::Surface& surf,
if (extra >= AI_MAX_NUMBER_OF_TEXTURECOORDS) { if (extra >= AI_MAX_NUMBER_OF_TEXTURECOORDS) {
DefaultLogger::get()->error("LWO: Maximum number of UV channels for " ASSIMP_LOG_ERROR("LWO: Maximum number of UV channels for "
"this mesh reached. Skipping channel \'" + uv.name + "\'"); "this mesh reached. Skipping channel \'" + uv.name + "\'");
} }
@ -502,7 +502,7 @@ void LWOImporter::FindVCChannels(const LWO::Surface& surf, LWO::SortedRep& sorte
if (vc.abAssigned[idx] && ((aiColor4D*)&vc.rawData[0])[idx] != aiColor4D(0.0,0.0,0.0,1.0)) { if (vc.abAssigned[idx] && ((aiColor4D*)&vc.rawData[0])[idx] != aiColor4D(0.0,0.0,0.0,1.0)) {
if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) { if (next >= AI_MAX_NUMBER_OF_COLOR_SETS) {
DefaultLogger::get()->error("LWO: Maximum number of vertex color channels for " ASSIMP_LOG_ERROR("LWO: Maximum number of vertex color channels for "
"this mesh reached. Skipping channel \'" + vc.name + "\'"); "this mesh reached. Skipping channel \'" + vc.name + "\'");
} }
@ -567,7 +567,7 @@ void LWOImporter::LoadLWO2ImageMap(unsigned int size, LWO::Texture& tex )
void LWOImporter::LoadLWO2Procedural(unsigned int /*size*/, LWO::Texture& tex ) void LWOImporter::LoadLWO2Procedural(unsigned int /*size*/, LWO::Texture& tex )
{ {
// --- not supported at the moment // --- not supported at the moment
DefaultLogger::get()->error("LWO2: Found procedural texture, this is not supported"); ASSIMP_LOG_ERROR("LWO2: Found procedural texture, this is not supported");
tex.bCanUse = false; tex.bCanUse = false;
} }
@ -575,7 +575,7 @@ void LWOImporter::LoadLWO2Procedural(unsigned int /*size*/, LWO::Texture& tex )
void LWOImporter::LoadLWO2Gradient(unsigned int /*size*/, LWO::Texture& tex ) void LWOImporter::LoadLWO2Gradient(unsigned int /*size*/, LWO::Texture& tex )
{ {
// --- not supported at the moment // --- not supported at the moment
DefaultLogger::get()->error("LWO2: Found gradient texture, this is not supported"); ASSIMP_LOG_ERROR("LWO2: Found gradient texture, this is not supported");
tex.bCanUse = false; tex.bCanUse = false;
} }
@ -590,7 +590,7 @@ void LWOImporter::LoadLWO2TextureHeader(unsigned int size, LWO::Texture& tex )
// we could crash later if this is an empty string ... // we could crash later if this is an empty string ...
if (!tex.ordinal.length()) if (!tex.ordinal.length())
{ {
DefaultLogger::get()->error("LWO2: Ill-formed SURF.BLOK ordinal string"); ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string");
tex.ordinal = "\x00"; tex.ordinal = "\x00";
} }
while (true) while (true)
@ -662,7 +662,7 @@ void LWOImporter::LoadLWO2TextureBlock(LE_NCONST IFF::SubChunkHeader* head, unsi
case AI_LWO_REFL: case AI_LWO_REFL:
listRef = &surf.mReflectionTextures;break; listRef = &surf.mReflectionTextures;break;
default: default:
DefaultLogger::get()->warn("LWO2: Encountered unknown texture type"); ASSIMP_LOG_WARN("LWO2: Encountered unknown texture type");
return; return;
} }
@ -691,7 +691,7 @@ void LWOImporter::LoadLWO2ShaderBlock(LE_NCONST IFF::SubChunkHeader* /*head*/, u
// we could crash later if this is an empty string ... // we could crash later if this is an empty string ...
if (!shader.ordinal.length()) if (!shader.ordinal.length())
{ {
DefaultLogger::get()->error("LWO2: Ill-formed SURF.BLOK ordinal string"); ASSIMP_LOG_ERROR("LWO2: Ill-formed SURF.BLOK ordinal string");
shader.ordinal = "\x00"; shader.ordinal = "\x00";
} }
@ -750,7 +750,7 @@ void LWOImporter::LoadLWO2Surface(unsigned int size)
} }
} }
if (derived.size()) if (derived.size())
DefaultLogger::get()->warn("LWO2: Unable to find source surface: " + derived); ASSIMP_LOG_WARN("LWO2: Unable to find source surface: " + derived);
} }
while (true) while (true)
@ -886,7 +886,7 @@ void LWOImporter::LoadLWO2Surface(unsigned int size)
break; break;
default: default:
DefaultLogger::get()->warn("LWO2: Found an unsupported surface BLOK"); ASSIMP_LOG_WARN("LWO2: Found an unsupported surface BLOK");
}; };
break; break;

44
code/LWSLoader.cpp
View File

@ -105,7 +105,7 @@ void LWS::Element::Parse (const char*& buffer)
if (children.back().tokens[0] == "Plugin") if (children.back().tokens[0] == "Plugin")
{ {
DefaultLogger::get()->debug("LWS: Skipping over plugin-specific data"); ASSIMP_LOG_DEBUG("LWS: Skipping over plugin-specific data");
// strange stuff inside Plugin/Endplugin blocks. Needn't // strange stuff inside Plugin/Endplugin blocks. Needn't
// follow LWS syntax, so we skip over it // follow LWS syntax, so we skip over it
@ -200,7 +200,7 @@ void LWSImporter::SetupProperties(const Importer* pImp)
void LWSImporter::ReadEnvelope(const LWS::Element& dad, LWO::Envelope& fill ) void LWSImporter::ReadEnvelope(const LWS::Element& dad, LWO::Envelope& fill )
{ {
if (dad.children.empty()) { if (dad.children.empty()) {
DefaultLogger::get()->error("LWS: Envelope descriptions must not be empty"); ASSIMP_LOG_ERROR("LWS: Envelope descriptions must not be empty");
return; return;
} }
@ -248,7 +248,7 @@ void LWSImporter::ReadEnvelope(const LWS::Element& dad, LWO::Envelope& fill )
num = 4; num = 4;
break; break;
default: default:
DefaultLogger::get()->error("LWS: Unknown span type"); ASSIMP_LOG_ERROR("LWS: Unknown span type");
} }
for (unsigned int i = 0; i < num;++i) { for (unsigned int i = 0; i < num;++i) {
SkipSpaces(&c); SkipSpaces(&c);
@ -305,7 +305,7 @@ void LWSImporter::ReadEnvelope_Old(
return; return;
unexpected_end: unexpected_end:
DefaultLogger::get()->error("LWS: Encountered unexpected end of file while parsing object motion"); ASSIMP_LOG_ERROR("LWS: Encountered unexpected end of file while parsing object motion");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -352,7 +352,7 @@ void LWSImporter::BuildGraph(aiNode* nd, LWS::NodeDesc& src, std::vector<Attachm
if (src.path.length() ) { if (src.path.length() ) {
obj = batch.GetImport(src.id); obj = batch.GetImport(src.id);
if (!obj) { if (!obj) {
DefaultLogger::get()->error("LWS: Failed to read external file " + src.path); ASSIMP_LOG_ERROR("LWS: Failed to read external file " + src.path);
} }
else { else {
if (obj->mRootNode->mNumChildren == 1) { if (obj->mRootNode->mNumChildren == 1) {
@ -551,7 +551,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// get file format version and print to log // get file format version and print to log
++it; ++it;
unsigned int version = strtoul10((*it).tokens[0].c_str()); unsigned int version = strtoul10((*it).tokens[0].c_str());
DefaultLogger::get()->info("LWS file format version is " + (*it).tokens[0]); ASSIMP_LOG_INFO("LWS file format version is " + (*it).tokens[0]);
first = 0.; first = 0.;
last = 60.; last = 60.;
fps = 25.; /* seems to be a good default frame rate */ fps = 25.; /* seems to be a good default frame rate */
@ -656,7 +656,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
d.number = cur_object++; d.number = cur_object++;
nodes.push_back(d); nodes.push_back(d);
} }
else DefaultLogger::get()->error("LWS: Unexpected keyword: \'Channel\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Channel\'");
} }
// important: index of channel // important: index of channel
@ -673,7 +673,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'Envelope': a single animation channel // 'Envelope': a single animation channel
else if ((*it).tokens[0] == "Envelope") { else if ((*it).tokens[0] == "Envelope") {
if (nodes.empty() || nodes.back().channels.empty()) if (nodes.empty() || nodes.back().channels.empty())
DefaultLogger::get()->error("LWS: Unexpected keyword: \'Envelope\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Envelope\'");
else { else {
ReadEnvelope((*it),nodes.back().channels.back()); ReadEnvelope((*it),nodes.back().channels.back());
} }
@ -684,7 +684,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
(*it).tokens[0] == "LightMotion")) { (*it).tokens[0] == "LightMotion")) {
if (nodes.empty()) if (nodes.empty())
DefaultLogger::get()->error("LWS: Unexpected keyword: \'<Light|Object|Camera>Motion\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'<Light|Object|Camera>Motion\'");
else { else {
ReadEnvelope_Old(it,root.children.end(),nodes.back(),version); ReadEnvelope_Old(it,root.children.end(),nodes.back(),version);
} }
@ -692,7 +692,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'Pre/PostBehavior': pre/post animation behaviour for LWSC 2 // 'Pre/PostBehavior': pre/post animation behaviour for LWSC 2
else if (version == 2 && (*it).tokens[0] == "Pre/PostBehavior") { else if (version == 2 && (*it).tokens[0] == "Pre/PostBehavior") {
if (nodes.empty()) if (nodes.empty())
DefaultLogger::get()->error("LWS: Unexpected keyword: \'Pre/PostBehavior'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'Pre/PostBehavior'");
else { else {
for (std::list<LWO::Envelope>::iterator it = nodes.back().channels.begin(); it != nodes.back().channels.end(); ++it) { for (std::list<LWO::Envelope>::iterator it = nodes.back().channels.begin(); it != nodes.back().channels.end(); ++it) {
// two ints per envelope // two ints per envelope
@ -705,14 +705,14 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'ParentItem': specifies the parent of the current element // 'ParentItem': specifies the parent of the current element
else if ((*it).tokens[0] == "ParentItem") { else if ((*it).tokens[0] == "ParentItem") {
if (nodes.empty()) if (nodes.empty())
DefaultLogger::get()->error("LWS: Unexpected keyword: \'ParentItem\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'ParentItem\'");
else nodes.back().parent = strtoul16(c,&c); else nodes.back().parent = strtoul16(c,&c);
} }
// 'ParentObject': deprecated one for older formats // 'ParentObject': deprecated one for older formats
else if (version < 3 && (*it).tokens[0] == "ParentObject") { else if (version < 3 && (*it).tokens[0] == "ParentObject") {
if (nodes.empty()) if (nodes.empty())
DefaultLogger::get()->error("LWS: Unexpected keyword: \'ParentObject\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'ParentObject\'");
else { else {
nodes.back().parent = strtoul10(c,&c) | (1u << 28u); nodes.back().parent = strtoul10(c,&c) | (1u << 28u);
@ -736,7 +736,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'CameraName': set name of currently active camera // 'CameraName': set name of currently active camera
else if ((*it).tokens[0] == "CameraName") { else if ((*it).tokens[0] == "CameraName") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::CAMERA) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::CAMERA)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'CameraName\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'CameraName\'");
else nodes.back().name = c; else nodes.back().name = c;
} }
@ -758,14 +758,14 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'LightName': set name of currently active light // 'LightName': set name of currently active light
else if ((*it).tokens[0] == "LightName") { else if ((*it).tokens[0] == "LightName") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightName\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightName\'");
else nodes.back().name = c; else nodes.back().name = c;
} }
// 'LightIntensity': set intensity of currently active light // 'LightIntensity': set intensity of currently active light
else if ((*it).tokens[0] == "LightIntensity" || (*it).tokens[0] == "LgtIntensity" ) { else if ((*it).tokens[0] == "LightIntensity" || (*it).tokens[0] == "LgtIntensity" ) {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightIntensity\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightIntensity\'");
else fast_atoreal_move<float>(c, nodes.back().lightIntensity ); else fast_atoreal_move<float>(c, nodes.back().lightIntensity );
@ -773,7 +773,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'LightType': set type of currently active light // 'LightType': set type of currently active light
else if ((*it).tokens[0] == "LightType") { else if ((*it).tokens[0] == "LightType") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightType\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightType\'");
else nodes.back().lightType = strtoul10(c); else nodes.back().lightType = strtoul10(c);
@ -781,7 +781,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'LightFalloffType': set falloff type of currently active light // 'LightFalloffType': set falloff type of currently active light
else if ((*it).tokens[0] == "LightFalloffType") { else if ((*it).tokens[0] == "LightFalloffType") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightFalloffType\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightFalloffType\'");
else nodes.back().lightFalloffType = strtoul10(c); else nodes.back().lightFalloffType = strtoul10(c);
@ -789,7 +789,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'LightConeAngle': set cone angle of currently active light // 'LightConeAngle': set cone angle of currently active light
else if ((*it).tokens[0] == "LightConeAngle") { else if ((*it).tokens[0] == "LightConeAngle") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightConeAngle\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightConeAngle\'");
else nodes.back().lightConeAngle = fast_atof(c); else nodes.back().lightConeAngle = fast_atof(c);
@ -797,7 +797,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'LightEdgeAngle': set area where we're smoothing from min to max intensity // 'LightEdgeAngle': set area where we're smoothing from min to max intensity
else if ((*it).tokens[0] == "LightEdgeAngle") { else if ((*it).tokens[0] == "LightEdgeAngle") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightEdgeAngle\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightEdgeAngle\'");
else nodes.back().lightEdgeAngle = fast_atof(c); else nodes.back().lightEdgeAngle = fast_atof(c);
@ -805,7 +805,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'LightColor': set color of currently active light // 'LightColor': set color of currently active light
else if ((*it).tokens[0] == "LightColor") { else if ((*it).tokens[0] == "LightColor") {
if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT) if (nodes.empty() || nodes.back().type != LWS::NodeDesc::LIGHT)
DefaultLogger::get()->error("LWS: Unexpected keyword: \'LightColor\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'LightColor\'");
else { else {
c = fast_atoreal_move<float>(c, (float&) nodes.back().lightColor.r ); c = fast_atoreal_move<float>(c, (float&) nodes.back().lightColor.r );
@ -819,7 +819,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
// 'PivotPosition': position of local transformation origin // 'PivotPosition': position of local transformation origin
else if ((*it).tokens[0] == "PivotPosition" || (*it).tokens[0] == "PivotPoint") { else if ((*it).tokens[0] == "PivotPosition" || (*it).tokens[0] == "PivotPoint") {
if (nodes.empty()) if (nodes.empty())
DefaultLogger::get()->error("LWS: Unexpected keyword: \'PivotPosition\'"); ASSIMP_LOG_ERROR("LWS: Unexpected keyword: \'PivotPosition\'");
else { else {
c = fast_atoreal_move<float>(c, (float&) nodes.back().pivotPos.x ); c = fast_atoreal_move<float>(c, (float&) nodes.back().pivotPos.x );
SkipSpaces(&c); SkipSpaces(&c);
@ -840,7 +840,7 @@ void LWSImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
if (dit != it && *it == (*dit).parent) { if (dit != it && *it == (*dit).parent) {
if ((*dit).parent_resolved) { if ((*dit).parent_resolved) {
// fixme: it's still possible to produce an overflow due to cross references .. // fixme: it's still possible to produce an overflow due to cross references ..
DefaultLogger::get()->error("LWS: Found cross reference in scenegraph"); ASSIMP_LOG_ERROR("LWS: Found cross reference in scene-graph");
continue; continue;
} }

16
code/LimitBoneWeightsProcess.cpp
View File

@ -76,13 +76,13 @@ bool LimitBoneWeightsProcess::IsActive( unsigned int pFlags) const
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void LimitBoneWeightsProcess::Execute( aiScene* pScene) void LimitBoneWeightsProcess::Execute( aiScene* pScene) {
{ ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess begin");
DefaultLogger::get()->debug("LimitBoneWeightsProcess begin"); for (unsigned int a = 0; a < pScene->mNumMeshes; ++a ) {
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) ProcessMesh(pScene->mMeshes[a]);
ProcessMesh( pScene->mMeshes[a]); }
DefaultLogger::get()->debug("LimitBoneWeightsProcess end"); ASSIMP_LOG_DEBUG("LimitBoneWeightsProcess end");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -195,9 +195,7 @@ void LimitBoneWeightsProcess::ProcessMesh( aiMesh* pMesh)
} }
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
char buffer[1024]; ASSIMP_LOG_INFO_F("Removed ", removed, " weights. Input bones: ", old_bones, ". Output bones: ", pMesh->mNumBones );
ai_snprintf(buffer,1024,"Removed %u weights. Input bones: %u. Output bones: %u",removed,old_bones,pMesh->mNumBones);
DefaultLogger::get()->info(buffer);
} }
} }
} }

20
code/MD2Loader.cpp
View File

@ -83,7 +83,7 @@ void MD2::LookupNormalIndex(uint8_t iNormalIndex,aiVector3D& vOut)
{ {
// make sure the normal index has a valid value // make sure the normal index has a valid value
if (iNormalIndex >= ARRAYSIZE(g_avNormals)) { if (iNormalIndex >= ARRAYSIZE(g_avNormals)) {
DefaultLogger::get()->warn("Index overflow in Quake II normal vector list"); ASSIMP_LOG_WARN("Index overflow in Quake II normal vector list");
iNormalIndex = ARRAYSIZE(g_avNormals) - 1; iNormalIndex = ARRAYSIZE(g_avNormals) - 1;
} }
vOut = *((const aiVector3D*)(&g_avNormals[iNormalIndex])); vOut = *((const aiVector3D*)(&g_avNormals[iNormalIndex]));
@ -161,7 +161,7 @@ void MD2Importer::ValidateHeader( )
// check file format version // check file format version
if (m_pcHeader->version != 8) if (m_pcHeader->version != 8)
DefaultLogger::get()->warn( "Unsupported md2 file version. Continuing happily ..."); ASSIMP_LOG_WARN( "Unsupported md2 file version. Continuing happily ...");
// check some values whether they are valid // check some values whether they are valid
if (0 == m_pcHeader->numFrames) if (0 == m_pcHeader->numFrames)
@ -203,11 +203,11 @@ void MD2Importer::ValidateHeader( )
} }
if (m_pcHeader->numSkins > AI_MD2_MAX_SKINS) if (m_pcHeader->numSkins > AI_MD2_MAX_SKINS)
DefaultLogger::get()->warn("The model contains more skins than Quake 2 supports"); ASSIMP_LOG_WARN("The model contains more skins than Quake 2 supports");
if ( m_pcHeader->numFrames > AI_MD2_MAX_FRAMES) if ( m_pcHeader->numFrames > AI_MD2_MAX_FRAMES)
DefaultLogger::get()->warn("The model contains more frames than Quake 2 supports"); ASSIMP_LOG_WARN("The model contains more frames than Quake 2 supports");
if (m_pcHeader->numVertices > AI_MD2_MAX_VERTS) if (m_pcHeader->numVertices > AI_MD2_MAX_VERTS)
DefaultLogger::get()->warn("The model contains more vertices than Quake 2 supports"); ASSIMP_LOG_WARN("The model contains more vertices than Quake 2 supports");
if (m_pcHeader->numFrames <= configFrameID ) if (m_pcHeader->numFrames <= configFrameID )
throw DeadlyImportError("The requested frame is not existing the file"); throw DeadlyImportError("The requested frame is not existing the file");
@ -352,7 +352,7 @@ void MD2Importer::InternReadFile( const std::string& pFile,
pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0)); pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
} }
else{ else{
DefaultLogger::get()->warn("Texture file name has zero length. It will be skipped."); ASSIMP_LOG_WARN("Texture file name has zero length. It will be skipped.");
} }
} }
else { else {
@ -390,11 +390,11 @@ void MD2Importer::InternReadFile( const std::string& pFile,
// check whether the skin width or height are zero (this would // check whether the skin width or height are zero (this would
// cause a division through zero) // cause a division through zero)
if (!m_pcHeader->skinWidth) { if (!m_pcHeader->skinWidth) {
DefaultLogger::get()->error("MD2: No valid skin width given"); ASSIMP_LOG_ERROR("MD2: No valid skin width given");
} }
else fDivisorU = (float)m_pcHeader->skinWidth; else fDivisorU = (float)m_pcHeader->skinWidth;
if (!m_pcHeader->skinHeight){ if (!m_pcHeader->skinHeight){
DefaultLogger::get()->error("MD2: No valid skin height given"); ASSIMP_LOG_ERROR("MD2: No valid skin height given");
} }
else fDivisorV = (float)m_pcHeader->skinHeight; else fDivisorV = (float)m_pcHeader->skinHeight;
} }
@ -412,7 +412,7 @@ void MD2Importer::InternReadFile( const std::string& pFile,
// validate vertex indices // validate vertex indices
unsigned int iIndex = (unsigned int)pcTriangles[i].vertexIndices[c]; unsigned int iIndex = (unsigned int)pcTriangles[i].vertexIndices[c];
if (iIndex >= m_pcHeader->numVertices) { if (iIndex >= m_pcHeader->numVertices) {
DefaultLogger::get()->error("MD2: Vertex index is outside the allowed range"); ASSIMP_LOG_ERROR("MD2: Vertex index is outside the allowed range");
iIndex = m_pcHeader->numVertices-1; iIndex = m_pcHeader->numVertices-1;
} }
@ -440,7 +440,7 @@ void MD2Importer::InternReadFile( const std::string& pFile,
// validate texture coordinates // validate texture coordinates
iIndex = pcTriangles[i].textureIndices[c]; iIndex = pcTriangles[i].textureIndices[c];
if (iIndex >= m_pcHeader->numTexCoords) { if (iIndex >= m_pcHeader->numTexCoords) {
DefaultLogger::get()->error("MD2: UV index is outside the allowed range"); ASSIMP_LOG_ERROR("MD2: UV index is outside the allowed range");
iIndex = m_pcHeader->numTexCoords-1; iIndex = m_pcHeader->numTexCoords-1;
} }

57
code/MD3Loader.cpp
View File

@ -101,7 +101,7 @@ Q3Shader::BlendFunc StringToBlendFunc(const std::string& m)
if (m == "GL_ONE_MINUS_DST_COLOR") { if (m == "GL_ONE_MINUS_DST_COLOR") {
return Q3Shader::BLEND_GL_ONE_MINUS_DST_COLOR; return Q3Shader::BLEND_GL_ONE_MINUS_DST_COLOR;
} }
DefaultLogger::get()->error("Q3Shader: Unknown blend function: " + m); ASSIMP_LOG_ERROR("Q3Shader: Unknown blend function: " + m);
return Q3Shader::BLEND_NONE; return Q3Shader::BLEND_NONE;
} }
@ -113,7 +113,7 @@ bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* i
if (!file.get()) if (!file.get())
return false; // if we can't access the file, don't worry and return return false; // if we can't access the file, don't worry and return
DefaultLogger::get()->info("Loading Quake3 shader file " + pFile); ASSIMP_LOG_INFO_F("Loading Quake3 shader file ", pFile);
// read file in memory // read file in memory
const size_t s = file->FileSize(); const size_t s = file->FileSize();
@ -136,7 +136,7 @@ bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* i
// append to last section, if any // append to last section, if any
if (!curData) { if (!curData) {
DefaultLogger::get()->error("Q3Shader: Unexpected shader section token \'{\'"); ASSIMP_LOG_ERROR("Q3Shader: Unexpected shader section token \'{\'");
return true; // still no failure, the file is there return true; // still no failure, the file is there
} }
@ -206,19 +206,16 @@ bool Q3Shader::LoadShader(ShaderData& fill, const std::string& pFile,IOSystem* i
SkipSpaces(&buff); SkipSpaces(&buff);
if (!ASSIMP_strincmp(buff,"back",4)) { if (!ASSIMP_strincmp(buff,"back",4)) {
curData->cull = Q3Shader::CULL_CCW; curData->cull = Q3Shader::CULL_CCW;
} } else if (!ASSIMP_strincmp(buff,"front",5)) {
else if (!ASSIMP_strincmp(buff,"front",5)) {
curData->cull = Q3Shader::CULL_CW; curData->cull = Q3Shader::CULL_CW;
} } else if (!ASSIMP_strincmp(buff,"none",4) || !ASSIMP_strincmp(buff,"disable",7)) {
else if (!ASSIMP_strincmp(buff,"none",4) || !ASSIMP_strincmp(buff,"disable",7)) {
curData->cull = Q3Shader::CULL_NONE; curData->cull = Q3Shader::CULL_NONE;
} else {
ASSIMP_LOG_ERROR("Q3Shader: Unrecognized cull mode");
} }
else DefaultLogger::get()->error("Q3Shader: Unrecognized cull mode");
} }
} }
} } else {
else {
// add new section // add new section
fill.blocks.push_back(Q3Shader::ShaderDataBlock()); fill.blocks.push_back(Q3Shader::ShaderDataBlock());
curData = &fill.blocks.back(); curData = &fill.blocks.back();
@ -238,7 +235,7 @@ bool Q3Shader::LoadSkin(SkinData& fill, const std::string& pFile,IOSystem* io)
if (!file.get()) if (!file.get())
return false; // if we can't access the file, don't worry and return return false; // if we can't access the file, don't worry and return
DefaultLogger::get()->info("Loading Quake3 skin file " + pFile); ASSIMP_LOG_INFO("Loading Quake3 skin file " + pFile);
// read file in memory // read file in memory
const size_t s = file->FileSize(); const size_t s = file->FileSize();
@ -397,7 +394,7 @@ void MD3Importer::ValidateHeaderOffsets()
// Check file format version // Check file format version
if (pcHeader->VERSION > 15) if (pcHeader->VERSION > 15)
DefaultLogger::get()->warn( "Unsupported MD3 file version. Continuing happily ..."); ASSIMP_LOG_WARN( "Unsupported MD3 file version. Continuing happily ...");
// Check some offset values whether they are valid // Check some offset values whether they are valid
if (!pcHeader->NUM_SURFACES) if (!pcHeader->NUM_SURFACES)
@ -438,25 +435,24 @@ void MD3Importer::ValidateSurfaceHeaderOffsets(const MD3::Surface* pcSurf)
// Check whether all requirements for Q3 files are met. We don't // Check whether all requirements for Q3 files are met. We don't
// care, but probably someone does. // care, but probably someone does.
if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) { if (pcSurf->NUM_TRIANGLES > AI_MD3_MAX_TRIANGLES) {
DefaultLogger::get()->warn("MD3: Quake III triangle limit exceeded"); ASSIMP_LOG_WARN("MD3: Quake III triangle limit exceeded");
} }
if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) { if (pcSurf->NUM_SHADER > AI_MD3_MAX_SHADERS) {
DefaultLogger::get()->warn("MD3: Quake III shader limit exceeded"); ASSIMP_LOG_WARN("MD3: Quake III shader limit exceeded");
} }
if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) { if (pcSurf->NUM_VERTICES > AI_MD3_MAX_VERTS) {
DefaultLogger::get()->warn("MD3: Quake III vertex limit exceeded"); ASSIMP_LOG_WARN("MD3: Quake III vertex limit exceeded");
} }
if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) { if (pcSurf->NUM_FRAMES > AI_MD3_MAX_FRAMES) {
DefaultLogger::get()->warn("MD3: Quake III frame limit exceeded"); ASSIMP_LOG_WARN("MD3: Quake III frame limit exceeded");
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
const aiImporterDesc* MD3Importer::GetInfo () const const aiImporterDesc* MD3Importer::GetInfo () const {
{
return &desc; return &desc;
} }
@ -579,7 +575,7 @@ bool MD3Importer::ReadMultipartFile()
aiNode* tag_torso, *tag_head; aiNode* tag_torso, *tag_head;
std::vector<AttachmentInfo> attach; std::vector<AttachmentInfo> attach;
DefaultLogger::get()->info("Multi part MD3 player model: lower, upper and head parts are joined"); ASSIMP_LOG_INFO("Multi part MD3 player model: lower, upper and head parts are joined");
// ensure we won't try to load ourselves recursively // ensure we won't try to load ourselves recursively
BatchLoader::PropertyMap props; BatchLoader::PropertyMap props;
@ -600,21 +596,21 @@ bool MD3Importer::ReadMultipartFile()
// ... and get them. We need all of them. // ... and get them. We need all of them.
scene_lower = batch.GetImport(_lower); scene_lower = batch.GetImport(_lower);
if (!scene_lower) { if (!scene_lower) {
DefaultLogger::get()->error("M3D: Failed to read multi part model, lower.md3 fails to load"); ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, lower.md3 fails to load");
failure = "lower"; failure = "lower";
goto error_cleanup; goto error_cleanup;
} }
scene_upper = batch.GetImport(_upper); scene_upper = batch.GetImport(_upper);
if (!scene_upper) { if (!scene_upper) {
DefaultLogger::get()->error("M3D: Failed to read multi part model, upper.md3 fails to load"); ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, upper.md3 fails to load");
failure = "upper"; failure = "upper";
goto error_cleanup; goto error_cleanup;
} }
scene_head = batch.GetImport(_head); scene_head = batch.GetImport(_head);
if (!scene_head) { if (!scene_head) {
DefaultLogger::get()->error("M3D: Failed to read multi part model, head.md3 fails to load"); ASSIMP_LOG_ERROR("M3D: Failed to read multi part model, head.md3 fails to load");
failure = "head"; failure = "head";
goto error_cleanup; goto error_cleanup;
} }
@ -628,7 +624,7 @@ bool MD3Importer::ReadMultipartFile()
// tag_torso // tag_torso
tag_torso = scene_lower->mRootNode->FindNode("tag_torso"); tag_torso = scene_lower->mRootNode->FindNode("tag_torso");
if (!tag_torso) { if (!tag_torso) {
DefaultLogger::get()->error("M3D: Failed to find attachment tag for multi part model: tag_torso expected"); ASSIMP_LOG_ERROR("M3D: Failed to find attachment tag for multi part model: tag_torso expected");
goto error_cleanup; goto error_cleanup;
} }
scene_upper->mRootNode->mName.Set("upper"); scene_upper->mRootNode->mName.Set("upper");
@ -637,7 +633,7 @@ bool MD3Importer::ReadMultipartFile()
// tag_head // tag_head
tag_head = scene_upper->mRootNode->FindNode("tag_head"); tag_head = scene_upper->mRootNode->FindNode("tag_head");
if (!tag_head) { if (!tag_head) {
DefaultLogger::get()->error("M3D: Failed to find attachment tag for multi part model: tag_head expected"); ASSIMP_LOG_ERROR( "M3D: Failed to find attachment tag for multi part model: tag_head expected");
goto error_cleanup; goto error_cleanup;
} }
scene_head->mRootNode->mName.Set("head"); scene_head->mRootNode->mName.Set("head");
@ -890,7 +886,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
if (it != skins.textures.end()) { if (it != skins.textures.end()) {
texture_name = &*( _texture_name = (*it).second).begin(); texture_name = &*( _texture_name = (*it).second).begin();
DefaultLogger::get()->debug("MD3: Assigning skin texture " + (*it).second + " to surface " + pcSurfaces->NAME); ASSIMP_LOG_DEBUG_F("MD3: Assigning skin texture ", (*it).second, " to surface ", pcSurfaces->NAME);
(*it).resolved = true; // mark entry as resolved (*it).resolved = true; // mark entry as resolved
} }
@ -919,9 +915,10 @@ void MD3Importer::InternReadFile( const std::string& pFile,
if (dit != shaders.blocks.end()) { if (dit != shaders.blocks.end()) {
// Hurra, wir haben einen. Tolle Sache. // Hurra, wir haben einen. Tolle Sache.
shader = &*dit; shader = &*dit;
DefaultLogger::get()->info("Found shader record for " +without_ext ); ASSIMP_LOG_INFO("Found shader record for " +without_ext );
} else {
ASSIMP_LOG_WARN("Unable to find shader record for " + without_ext);
} }
else DefaultLogger::get()->warn("Unable to find shader record for " +without_ext );
} }
aiMaterial* pcHelper = new aiMaterial(); aiMaterial* pcHelper = new aiMaterial();
@ -950,7 +947,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
szString.Set(convertedPath); szString.Set(convertedPath);
} }
else { else {
DefaultLogger::get()->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");
} }
pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0)); pcHelper->AddProperty(&szString,AI_MATKEY_TEXTURE_DIFFUSE(0));
@ -1040,7 +1037,7 @@ void MD3Importer::InternReadFile( const std::string& pFile,
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
for (std::list< Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin();it != skins.textures.end(); ++it) { for (std::list< Q3Shader::SkinData::TextureEntry>::const_iterator it = skins.textures.begin();it != skins.textures.end(); ++it) {
if (!(*it).resolved) { if (!(*it).resolved) {
DefaultLogger::get()->error("MD3: Failed to match skin " + (*it).first + " to surface " + (*it).second); ASSIMP_LOG_ERROR_F("MD3: Failed to match skin ", (*it).first, " to surface ", (*it).second);
} }
} }
} }

9
code/MD5Loader.cpp
View File

@ -359,7 +359,7 @@ void MD5Importer::LoadMD5MeshFile ()
// Check whether we can read from the file // Check whether we can read from the file
if( file.get() == NULL || !file->FileSize()) { if( file.get() == NULL || !file->FileSize()) {
DefaultLogger::get()->warn("Failed to access MD5MESH file: " + pFile); ASSIMP_LOG_WARN("Failed to access MD5MESH file: " + pFile);
return; return;
} }
bHadMD5Mesh = true; bHadMD5Mesh = true;
@ -482,7 +482,7 @@ void MD5Importer::LoadMD5MeshFile ()
for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w) for (unsigned int jub = (*iter).mFirstWeight, w = jub; w < jub + (*iter).mNumWeights;++w)
fSum += meshSrc.mWeights[w].mWeight; fSum += meshSrc.mWeights[w].mWeight;
if (!fSum) { if (!fSum) {
DefaultLogger::get()->error("MD5MESH: The sum of all vertex bone weights is 0"); ASSIMP_LOG_ERROR("MD5MESH: The sum of all vertex bone weights is 0");
continue; continue;
} }
@ -574,7 +574,7 @@ void MD5Importer::LoadMD5AnimFile ()
// Check whether we can read from the file // Check whether we can read from the file
if( !file.get() || !file->FileSize()) { if( !file.get() || !file->FileSize()) {
DefaultLogger::get()->warn("Failed to read MD5ANIM file: " + pFile); ASSIMP_LOG_WARN("Failed to read MD5ANIM file: " + pFile);
return; return;
} }
LoadFileIntoMemory(file.get()); LoadFileIntoMemory(file.get());
@ -588,8 +588,7 @@ void MD5Importer::LoadMD5AnimFile ()
// generate and fill the output animation // generate and fill the output animation
if (animParser.mAnimatedBones.empty() || animParser.mFrames.empty() || if (animParser.mAnimatedBones.empty() || animParser.mFrames.empty() ||
animParser.mBaseFrames.size() != animParser.mAnimatedBones.size()) { animParser.mBaseFrames.size() != animParser.mAnimatedBones.size()) {
ASSIMP_LOG_ERROR("MD5ANIM: No frames or animated bones loaded");
DefaultLogger::get()->error("MD5ANIM: No frames or animated bones loaded");
} }
else { else {
bHadMD5Anim = true; bHadMD5Anim = true;

20
code/MD5Parser.cpp
View File

@ -70,7 +70,7 @@ MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
fileSize = _fileSize; fileSize = _fileSize;
lineNumber = 0; lineNumber = 0;
DefaultLogger::get()->debug("MD5Parser begin"); ASSIMP_LOG_DEBUG("MD5Parser begin");
// parse the file header // parse the file header
ParseHeader(); ParseHeader();
@ -88,7 +88,7 @@ MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
if ( !DefaultLogger::isNullLogger()) { if ( !DefaultLogger::isNullLogger()) {
char szBuffer[128]; // should be sufficiently large char szBuffer[128]; // should be sufficiently large
::ai_snprintf(szBuffer,128,"MD5Parser end. Parsed %i sections",(int)mSections.size()); ::ai_snprintf(szBuffer,128,"MD5Parser end. Parsed %i sections",(int)mSections.size());
DefaultLogger::get()->debug(szBuffer); ASSIMP_LOG_DEBUG(szBuffer);
} }
} }
@ -107,7 +107,7 @@ MD5Parser::MD5Parser(char* _buffer, unsigned int _fileSize )
{ {
char szBuffer[1024]; char szBuffer[1024];
::sprintf(szBuffer,"[MD5] Line %u: %s",line,warn); ::sprintf(szBuffer,"[MD5] Line %u: %s",line,warn);
DefaultLogger::get()->warn(szBuffer); ASSIMP_LOG_WARN(szBuffer);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -130,7 +130,7 @@ void MD5Parser::ParseHeader()
// FIX: can break the log length limit, so we need to be careful // FIX: can break the log length limit, so we need to be careful
char* sz = buffer; char* sz = buffer;
while (!IsLineEnd( *buffer++)); while (!IsLineEnd( *buffer++));
DefaultLogger::get()->info(std::string(sz,std::min((uintptr_t)MAX_LOG_MESSAGE_LENGTH, (uintptr_t)(buffer-sz)))); ASSIMP_LOG_INFO(std::string(sz,std::min((uintptr_t)MAX_LOG_MESSAGE_LENGTH, (uintptr_t)(buffer-sz))));
SkipSpacesAndLineEnd(); SkipSpacesAndLineEnd();
} }
@ -243,7 +243,7 @@ bool MD5Parser::ParseSection(Section& out)
// .MD5MESH parsing function // .MD5MESH parsing function
MD5MeshParser::MD5MeshParser(SectionList& mSections) MD5MeshParser::MD5MeshParser(SectionList& mSections)
{ {
DefaultLogger::get()->debug("MD5MeshParser begin"); ASSIMP_LOG_DEBUG("MD5MeshParser begin");
// now parse all sections // now parse all sections
for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter){ for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter){
@ -354,14 +354,14 @@ MD5MeshParser::MD5MeshParser(SectionList& mSections)
} }
} }
} }
DefaultLogger::get()->debug("MD5MeshParser end"); ASSIMP_LOG_DEBUG("MD5MeshParser end");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// .MD5ANIM parsing function // .MD5ANIM parsing function
MD5AnimParser::MD5AnimParser(SectionList& mSections) MD5AnimParser::MD5AnimParser(SectionList& mSections)
{ {
DefaultLogger::get()->debug("MD5AnimParser begin"); ASSIMP_LOG_DEBUG("MD5AnimParser begin");
fFrameRate = 24.0f; fFrameRate = 24.0f;
mNumAnimatedComponents = UINT_MAX; mNumAnimatedComponents = UINT_MAX;
@ -445,14 +445,14 @@ MD5AnimParser::MD5AnimParser(SectionList& mSections)
fast_atoreal_move<float>((*iter).mGlobalValue.c_str(),fFrameRate); fast_atoreal_move<float>((*iter).mGlobalValue.c_str(),fFrameRate);
} }
} }
DefaultLogger::get()->debug("MD5AnimParser end"); ASSIMP_LOG_DEBUG("MD5AnimParser end");
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// .MD5CAMERA parsing function // .MD5CAMERA parsing function
MD5CameraParser::MD5CameraParser(SectionList& mSections) MD5CameraParser::MD5CameraParser(SectionList& mSections)
{ {
DefaultLogger::get()->debug("MD5CameraParser begin"); ASSIMP_LOG_DEBUG("MD5CameraParser begin");
fFrameRate = 24.0f; fFrameRate = 24.0f;
for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter) { for (SectionList::const_iterator iter = mSections.begin(), iterEnd = mSections.end();iter != iterEnd;++iter) {
@ -483,6 +483,6 @@ MD5CameraParser::MD5CameraParser(SectionList& mSections)
} }
} }
} }
DefaultLogger::get()->debug("MD5CameraParser end"); ASSIMP_LOG_DEBUG("MD5CameraParser end");
} }

10
code/MDCLoader.cpp
View File

@ -159,8 +159,9 @@ void MDCImporter::ValidateHeader()
"magic word found is " + std::string( szBuffer )); "magic word found is " + std::string( szBuffer ));
} }
if (pcHeader->ulVersion != AI_MDC_VERSION) if (pcHeader->ulVersion != AI_MDC_VERSION) {
DefaultLogger::get()->warn("Unsupported MDC file version (2 (AI_MDC_VERSION) was expected)"); ASSIMP_LOG_WARN("Unsupported MDC file version (2 (AI_MDC_VERSION) was expected)");
}
if (pcHeader->ulOffsetBorderFrames + pcHeader->ulNumFrames * sizeof(MDC::Frame) > this->fileSize || if (pcHeader->ulOffsetBorderFrames + pcHeader->ulNumFrames * sizeof(MDC::Frame) > this->fileSize ||
pcHeader->ulOffsetSurfaces + pcHeader->ulNumSurfaces * sizeof(MDC::Surface) > this->fileSize) pcHeader->ulOffsetSurfaces + pcHeader->ulNumSurfaces * sizeof(MDC::Surface) > this->fileSize)
@ -169,8 +170,9 @@ void MDCImporter::ValidateHeader()
"and point to something behind the file."); "and point to something behind the file.");
} }
if (this->configFrameID >= this->pcHeader->ulNumFrames) if (this->configFrameID >= this->pcHeader->ulNumFrames) {
throw DeadlyImportError("The requested frame is not available"); throw DeadlyImportError("The requested frame is not available");
}
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -388,7 +390,7 @@ void MDCImporter::InternReadFile(
uint32_t quak = pcTriangle->aiIndices[iIndex]; uint32_t quak = pcTriangle->aiIndices[iIndex];
if (quak >= pcSurface->ulNumVertices) if (quak >= pcSurface->ulNumVertices)
{ {
DefaultLogger::get()->error("MDC vertex index is out of range"); ASSIMP_LOG_ERROR("MDC vertex index is out of range");
quak = pcSurface->ulNumVertices-1; quak = pcSurface->ulNumVertices-1;
} }

64
code/MDLLoader.cpp
View File

@ -187,37 +187,37 @@ void MDLImporter::InternReadFile( const std::string& pFile,
// Original Quake1 format // Original Quake1 format
if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord) { if (AI_MDL_MAGIC_NUMBER_BE == iMagicWord || AI_MDL_MAGIC_NUMBER_LE == iMagicWord) {
DefaultLogger::get()->debug("MDL subtype: Quake 1, magic word is IDPO"); ASSIMP_LOG_DEBUG("MDL subtype: Quake 1, magic word is IDPO");
iGSFileVersion = 0; iGSFileVersion = 0;
InternReadFile_Quake1(); InternReadFile_Quake1();
} }
// GameStudio A<old> MDL2 format - used by some test models that come with 3DGS // GameStudio A<old> MDL2 format - used by some test models that come with 3DGS
else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord) { else if (AI_MDL_MAGIC_NUMBER_BE_GS3 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS3 == iMagicWord) {
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A2, magic word is MDL2"); ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A2, magic word is MDL2");
iGSFileVersion = 2; iGSFileVersion = 2;
InternReadFile_Quake1(); InternReadFile_Quake1();
} }
// GameStudio A4 MDL3 format // GameStudio A4 MDL3 format
else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord) { else if (AI_MDL_MAGIC_NUMBER_BE_GS4 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS4 == iMagicWord) {
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A4, magic word is MDL3"); ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL3");
iGSFileVersion = 3; iGSFileVersion = 3;
InternReadFile_3DGS_MDL345(); InternReadFile_3DGS_MDL345();
} }
// GameStudio A5+ MDL4 format // GameStudio A5+ MDL4 format
else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord) { else if (AI_MDL_MAGIC_NUMBER_BE_GS5a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5a == iMagicWord) {
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A4, magic word is MDL4"); ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A4, magic word is MDL4");
iGSFileVersion = 4; iGSFileVersion = 4;
InternReadFile_3DGS_MDL345(); InternReadFile_3DGS_MDL345();
} }
// GameStudio A5+ MDL5 format // GameStudio A5+ MDL5 format
else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord) { else if (AI_MDL_MAGIC_NUMBER_BE_GS5b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS5b == iMagicWord) {
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A5, magic word is MDL5"); ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A5, magic word is MDL5");
iGSFileVersion = 5; iGSFileVersion = 5;
InternReadFile_3DGS_MDL345(); InternReadFile_3DGS_MDL345();
} }
// GameStudio A7 MDL7 format // GameStudio A7 MDL7 format
else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord) { else if (AI_MDL_MAGIC_NUMBER_BE_GS7 == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_GS7 == iMagicWord) {
DefaultLogger::get()->debug("MDL subtype: 3D GameStudio A7, magic word is MDL7"); ASSIMP_LOG_DEBUG("MDL subtype: 3D GameStudio A7, magic word is MDL7");
iGSFileVersion = 7; iGSFileVersion = 7;
InternReadFile_3DGS_MDL7(); InternReadFile_3DGS_MDL7();
} }
@ -225,7 +225,7 @@ void MDLImporter::InternReadFile( const std::string& pFile,
else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord || else if (AI_MDL_MAGIC_NUMBER_BE_HL2a == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2a == iMagicWord ||
AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord) AI_MDL_MAGIC_NUMBER_BE_HL2b == iMagicWord || AI_MDL_MAGIC_NUMBER_LE_HL2b == iMagicWord)
{ {
DefaultLogger::get()->debug("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ"); ASSIMP_LOG_DEBUG("MDL subtype: Source(tm) Engine, magic word is IDST/IDSQ");
iGSFileVersion = 0; iGSFileVersion = 0;
InternReadFile_HL2(); InternReadFile_HL2();
} }
@ -258,7 +258,7 @@ void MDLImporter::SizeCheck(const void* szPos)
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Just for debgging purposes // Just for debugging purposes
void MDLImporter::SizeCheck(const void* szPos, const char* szFile, unsigned int iLine) void MDLImporter::SizeCheck(const void* szPos, const char* szFile, unsigned int iLine)
{ {
ai_assert(NULL != szFile); ai_assert(NULL != szFile);
@ -298,20 +298,20 @@ void MDLImporter::ValidateHeader_Quake1(const MDL::Header* pcHeader)
if (!this->iGSFileVersion) if (!this->iGSFileVersion)
{ {
if (pcHeader->num_verts > AI_MDL_MAX_VERTS) if (pcHeader->num_verts > AI_MDL_MAX_VERTS)
DefaultLogger::get()->warn("Quake 1 MDL model has more than AI_MDL_MAX_VERTS vertices"); ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_VERTS vertices");
if (pcHeader->num_tris > AI_MDL_MAX_TRIANGLES) if (pcHeader->num_tris > AI_MDL_MAX_TRIANGLES)
DefaultLogger::get()->warn("Quake 1 MDL model has more than AI_MDL_MAX_TRIANGLES triangles"); ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_TRIANGLES triangles");
if (pcHeader->num_frames > AI_MDL_MAX_FRAMES) if (pcHeader->num_frames > AI_MDL_MAX_FRAMES)
DefaultLogger::get()->warn("Quake 1 MDL model has more than AI_MDL_MAX_FRAMES frames"); ASSIMP_LOG_WARN("Quake 1 MDL model has more than AI_MDL_MAX_FRAMES frames");
// (this does not apply for 3DGS MDLs) // (this does not apply for 3DGS MDLs)
if (!this->iGSFileVersion && pcHeader->version != AI_MDL_VERSION) if (!this->iGSFileVersion && pcHeader->version != AI_MDL_VERSION)
DefaultLogger::get()->warn("Quake 1 MDL model has an unknown version: AI_MDL_VERSION (=6) is " ASSIMP_LOG_WARN("Quake 1 MDL model has an unknown version: AI_MDL_VERSION (=6) is "
"the expected file format version"); "the expected file format version");
if(pcHeader->num_skins && (!pcHeader->skinwidth || !pcHeader->skinheight)) if(pcHeader->num_skins && (!pcHeader->skinwidth || !pcHeader->skinheight))
DefaultLogger::get()->warn("Skin width or height are 0"); ASSIMP_LOG_WARN("Skin width or height are 0");
} }
} }
@ -481,7 +481,7 @@ void MDLImporter::InternReadFile_Quake1() {
if (iIndex >= (unsigned int)pcHeader->num_verts) if (iIndex >= (unsigned int)pcHeader->num_verts)
{ {
iIndex = pcHeader->num_verts-1; iIndex = pcHeader->num_verts-1;
DefaultLogger::get()->warn("Index overflow in Q1-MDL vertex list."); ASSIMP_LOG_WARN("Index overflow in Q1-MDL vertex list.");
} }
aiVector3D& vec = pcMesh->mVertices[iCurrent]; aiVector3D& vec = pcMesh->mVertices[iCurrent];
@ -692,7 +692,7 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
unsigned int iIndex = pcTriangles->index_xyz[c]; unsigned int iIndex = pcTriangles->index_xyz[c];
if (iIndex >= (unsigned int)pcHeader->num_verts) { if (iIndex >= (unsigned int)pcHeader->num_verts) {
iIndex = pcHeader->num_verts-1; iIndex = pcHeader->num_verts-1;
DefaultLogger::get()->warn("Index overflow in MDLn vertex list"); ASSIMP_LOG_WARN("Index overflow in MDLn vertex list");
} }
aiVector3D& vec = pcMesh->mVertices[iCurrent]; aiVector3D& vec = pcMesh->mVertices[iCurrent];
@ -747,7 +747,7 @@ void MDLImporter::InternReadFile_3DGS_MDL345( )
unsigned int iIndex = pcTriangles->index_xyz[c]; unsigned int iIndex = pcTriangles->index_xyz[c];
if (iIndex >= (unsigned int)pcHeader->num_verts) { if (iIndex >= (unsigned int)pcHeader->num_verts) {
iIndex = pcHeader->num_verts-1; iIndex = pcHeader->num_verts-1;
DefaultLogger::get()->warn("Index overflow in MDLn vertex list"); ASSIMP_LOG_WARN("Index overflow in MDLn vertex list");
} }
aiVector3D& vec = pcMesh->mVertices[iCurrent]; aiVector3D& vec = pcMesh->mVertices[iCurrent];
@ -798,7 +798,7 @@ void MDLImporter::ImportUVCoordinate_3DGS_MDL345(
// validate UV indices // validate UV indices
if (iIndex >= (unsigned int) pcHeader->synctype) { if (iIndex >= (unsigned int) pcHeader->synctype) {
iIndex = pcHeader->synctype-1; iIndex = pcHeader->synctype-1;
DefaultLogger::get()->warn("Index overflow in MDLn UV coord list"); ASSIMP_LOG_WARN("Index overflow in MDLn UV coord list");
} }
float s = (float)pcSrc[iIndex].u; float s = (float)pcSrc[iIndex].u;
@ -835,7 +835,7 @@ void MDLImporter::CalculateUVCoordinates_MDL5()
iWidth = (unsigned int)*piPtr; iWidth = (unsigned int)*piPtr;
if (!iHeight || !iWidth) if (!iHeight || !iWidth)
{ {
DefaultLogger::get()->warn("Either the width or the height of the " ASSIMP_LOG_WARN("Either the width or the height of the "
"embedded DDS texture is zero. Unable to compute final texture " "embedded DDS texture is zero. Unable to compute final texture "
"coordinates. The texture coordinates remain in their original " "coordinates. The texture coordinates remain in their original "
"0-x/0-y (x,y = texture size) range."); "0-x/0-y (x,y = texture size) range.");
@ -988,7 +988,7 @@ MDL::IntBone_MDL7** MDLImporter::LoadBones_3DGS_MDL7()
AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_32_CHARS != pcHeader->bone_stc_size && AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_32_CHARS != pcHeader->bone_stc_size &&
AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE != pcHeader->bone_stc_size) AI_MDL7_BONE_STRUCT_SIZE__NAME_IS_NOT_THERE != pcHeader->bone_stc_size)
{ {
DefaultLogger::get()->warn("Unknown size of bone data structure"); ASSIMP_LOG_WARN("Unknown size of bone data structure");
return NULL; return NULL;
} }
@ -1026,7 +1026,7 @@ void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
if(iIndex > (unsigned int)groupInfo.pcGroup->numverts) { if(iIndex > (unsigned int)groupInfo.pcGroup->numverts) {
// (we might need to read this section a second time - to process frame vertices correctly) // (we might need to read this section a second time - to process frame vertices correctly)
pcGroupTris->v_index[c] = iIndex = groupInfo.pcGroup->numverts-1; pcGroupTris->v_index[c] = iIndex = groupInfo.pcGroup->numverts-1;
DefaultLogger::get()->warn("Index overflow in MDL7 vertex list"); ASSIMP_LOG_WARN("Index overflow in MDL7 vertex list");
} }
// write the output face index // write the output face index
@ -1071,7 +1071,7 @@ void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
iIndex = pcGroupTris->skinsets[0].st_index[c]; iIndex = pcGroupTris->skinsets[0].st_index[c];
if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) { if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
iIndex = groupInfo.pcGroup->num_stpts-1; iIndex = groupInfo.pcGroup->num_stpts-1;
DefaultLogger::get()->warn("Index overflow in MDL7 UV coordinate list (#1)"); ASSIMP_LOG_WARN("Index overflow in MDL7 UV coordinate list (#1)");
} }
float u = groupInfo.pcGroupUVs[iIndex].u; float u = groupInfo.pcGroupUVs[iIndex].u;
@ -1098,7 +1098,7 @@ void MDLImporter::ReadFaces_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInfo,
iIndex = pcGroupTris->skinsets[1].st_index[c]; iIndex = pcGroupTris->skinsets[1].st_index[c];
if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) { if(iIndex > (unsigned int)groupInfo.pcGroup->num_stpts) {
iIndex = groupInfo.pcGroup->num_stpts-1; iIndex = groupInfo.pcGroup->num_stpts-1;
DefaultLogger::get()->warn("Index overflow in MDL7 UV coordinate list (#2)"); ASSIMP_LOG_WARN("Index overflow in MDL7 UV coordinate list (#2)");
} }
float u = groupInfo.pcGroupUVs[ iIndex ].u; float u = groupInfo.pcGroupUVs[ iIndex ].u;
@ -1153,7 +1153,7 @@ bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInf
frame.pcFrame->transmatrix_count * pcHeader->bonetrans_stc_size; frame.pcFrame->transmatrix_count * pcHeader->bonetrans_stc_size;
if (((const char*)szCurrent - (const char*)pcHeader) + iAdd > (unsigned int)pcHeader->data_size) { if (((const char*)szCurrent - (const char*)pcHeader) + iAdd > (unsigned int)pcHeader->data_size) {
DefaultLogger::get()->warn("Index overflow in frame area. " ASSIMP_LOG_WARN("Index overflow in frame area. "
"Ignoring all frames and all further mesh groups, too."); "Ignoring all frames and all further mesh groups, too.");
// don't parse more groups if we can't even read one // don't parse more groups if we can't even read one
@ -1171,7 +1171,7 @@ bool MDLImporter::ProcessFrames_3DGS_MDL7(const MDL::IntGroupInfo_MDL7& groupInf
uint16_t iIndex = _AI_MDL7_ACCESS(pcFrameVertices,qq,pcHeader->framevertex_stc_size,MDL::Vertex_MDL7).vertindex; uint16_t iIndex = _AI_MDL7_ACCESS(pcFrameVertices,qq,pcHeader->framevertex_stc_size,MDL::Vertex_MDL7).vertindex;
AI_SWAP2(iIndex); AI_SWAP2(iIndex);
if (iIndex >= groupInfo.pcGroup->numverts) { if (iIndex >= groupInfo.pcGroup->numverts) {
DefaultLogger::get()->warn("Invalid vertex index in frame vertex section"); ASSIMP_LOG_WARN("Invalid vertex index in frame vertex section");
continue; continue;
} }
@ -1257,7 +1257,7 @@ void MDLImporter::SortByMaterials_3DGS_MDL7(
// sometimes MED writes -1, but normally only if there is only // sometimes MED writes -1, but normally only if there is only
// one skin assigned. No warning in this case // one skin assigned. No warning in this case
if(0xFFFFFFFF != groupData.pcFaces[iFace].iMatIndex[0]) if(0xFFFFFFFF != groupData.pcFaces[iFace].iMatIndex[0])
DefaultLogger::get()->warn("Index overflow in MDL7 material list [#0]"); ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#0]");
} }
else splitGroupData.aiSplit[groupData.pcFaces[iFace]. else splitGroupData.aiSplit[groupData.pcFaces[iFace].
iMatIndex[0]]->push_back(iFace); iMatIndex[0]]->push_back(iFace);
@ -1282,7 +1282,7 @@ void MDLImporter::SortByMaterials_3DGS_MDL7(
// sometimes MED writes -1, but normally only if there is only // sometimes MED writes -1, but normally only if there is only
// one skin assigned. No warning in this case // one skin assigned. No warning in this case
if(UINT_MAX != iMatIndex) if(UINT_MAX != iMatIndex)
DefaultLogger::get()->warn("Index overflow in MDL7 material list [#1]"); ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#1]");
iMatIndex = iNumMaterials-1; iMatIndex = iNumMaterials-1;
} }
unsigned int iMatIndex2 = groupData.pcFaces[iFace].iMatIndex[1]; unsigned int iMatIndex2 = groupData.pcFaces[iFace].iMatIndex[1];
@ -1292,7 +1292,7 @@ void MDLImporter::SortByMaterials_3DGS_MDL7(
if (iMatIndex2 >= iNumMaterials) { if (iMatIndex2 >= iNumMaterials) {
// sometimes MED writes -1, but normally only if there is only // sometimes MED writes -1, but normally only if there is only
// one skin assigned. No warning in this case // one skin assigned. No warning in this case
DefaultLogger::get()->warn("Index overflow in MDL7 material list [#2]"); ASSIMP_LOG_WARN("Index overflow in MDL7 material list [#2]");
iMatIndex2 = iNumMaterials-1; iMatIndex2 = iNumMaterials-1;
} }
@ -1414,7 +1414,7 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
if (1 != groupInfo.pcGroup->typ) { if (1 != groupInfo.pcGroup->typ) {
// Not a triangle-based mesh // Not a triangle-based mesh
DefaultLogger::get()->warn("[3DGS MDL7] Not a triangle mesh group. Continuing happily"); ASSIMP_LOG_WARN("[3DGS MDL7] Not a triangle mesh group. Continuing happily");
} }
// store the name of the group // store the name of the group
@ -1516,7 +1516,7 @@ void MDLImporter::InternReadFile_3DGS_MDL7( )
sharedData.abNeedMaterials[qq] = true; sharedData.abNeedMaterials[qq] = true;
} }
} }
else DefaultLogger::get()->warn("[3DGS MDL7] Mesh group consists of 0 " else ASSIMP_LOG_WARN("[3DGS MDL7] Mesh group consists of 0 "
"vertices or faces. It will be skipped."); "vertices or faces. It will be skipped.");
// process all frames and generate output meshes // process all frames and generate output meshes
@ -1664,7 +1664,7 @@ void MDLImporter::ParseBoneTrafoKeys_3DGS_MDL7(
// read all transformation matrices // read all transformation matrices
for (unsigned int iTrafo = 0; iTrafo < frame.pcFrame->transmatrix_count;++iTrafo) { for (unsigned int iTrafo = 0; iTrafo < frame.pcFrame->transmatrix_count;++iTrafo) {
if(pcBoneTransforms->bone_index >= pcHeader->bones_num) { if(pcBoneTransforms->bone_index >= pcHeader->bones_num) {
DefaultLogger::get()->warn("Index overflow in frame area. " ASSIMP_LOG_WARN("Index overflow in frame area. "
"Unable to parse this bone transformation"); "Unable to parse this bone transformation");
} }
else { else {
@ -1676,7 +1676,7 @@ void MDLImporter::ParseBoneTrafoKeys_3DGS_MDL7(
} }
} }
else { else {
DefaultLogger::get()->warn("Ignoring animation keyframes in groups != 0"); ASSIMP_LOG_WARN("Ignoring animation keyframes in groups != 0");
} }
} }
} }
@ -1894,7 +1894,7 @@ void MDLImporter::GenerateOutputMeshes_3DGS_MDL7(
unsigned int iBone = groupData.aiBones[ oldFace.mIndices[c] ]; unsigned int iBone = groupData.aiBones[ oldFace.mIndices[c] ];
if (UINT_MAX != iBone) { if (UINT_MAX != iBone) {
if (iBone >= iNumOutBones) { if (iBone >= iNumOutBones) {
DefaultLogger::get()->error("Bone index overflow. " ASSIMP_LOG_ERROR("Bone index overflow. "
"The bone index of a vertex exceeds the allowed range. "); "The bone index of a vertex exceeds the allowed range. ");
iBone = iNumOutBones-1; iBone = iNumOutBones-1;
} }

17
code/MDLMaterialLoader.cpp
View File

@ -64,7 +64,7 @@ using namespace Assimp;
static aiTexel* const bad_texel = reinterpret_cast<aiTexel*>(SIZE_MAX); static aiTexel* const bad_texel = reinterpret_cast<aiTexel*>(SIZE_MAX);
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Find a suitable pallette file or take the default one // Find a suitable palette file or take the default one
void MDLImporter::SearchPalette(const unsigned char** pszColorMap) void MDLImporter::SearchPalette(const unsigned char** pszColorMap)
{ {
// now try to find the color map in the current directory // now try to find the color map in the current directory
@ -75,10 +75,11 @@ void MDLImporter::SearchPalette(const unsigned char** pszColorMap)
{ {
if (pcStream->FileSize() >= 768) if (pcStream->FileSize() >= 768)
{ {
unsigned char* colorMap = new unsigned char[256*3]; size_t len = 256 * 3;
unsigned char* colorMap = new unsigned char[len];
szColorMap = colorMap; szColorMap = colorMap;
pcStream->Read(colorMap,256*3,1); pcStream->Read(colorMap, len,1);
DefaultLogger::get()->info("Found valid colormap.lmp in directory. " ASSIMP_LOG_INFO("Found valid colormap.lmp in directory. "
"It will be used to decode embedded textures in palletized formats."); "It will be used to decode embedded textures in palletized formats.");
} }
delete pcStream; delete pcStream;
@ -186,7 +187,7 @@ void MDLImporter::CreateTexture_3DGS_MDL4(const unsigned char* szData,
if (iType == 1 || iType > 3) if (iType == 1 || iType > 3)
{ {
DefaultLogger::get()->error("Unsupported texture file format"); ASSIMP_LOG_ERROR("Unsupported texture file format");
return; return;
} }
@ -508,7 +509,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
// ***** EMBEDDED DDS FILE ***** // ***** EMBEDDED DDS FILE *****
if (1 != iHeight) if (1 != iHeight)
{ {
DefaultLogger::get()->warn("Found a reference to an embedded DDS texture, " ASSIMP_LOG_WARN("Found a reference to an embedded DDS texture, "
"but texture height is not equal to 1, which is not supported by MED"); "but texture height is not equal to 1, which is not supported by MED");
} }
@ -531,7 +532,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
// ***** REFERENCE TO EXTERNAL FILE ***** // ***** REFERENCE TO EXTERNAL FILE *****
if (1 != iHeight) if (1 != iHeight)
{ {
DefaultLogger::get()->warn("Found a reference to an external texture, " ASSIMP_LOG_WARN("Found a reference to an external texture, "
"but texture height is not equal to 1, which is not supported by MED"); "but texture height is not equal to 1, which is not supported by MED");
} }
@ -552,7 +553,7 @@ void MDLImporter::ParseSkinLump_3DGS_MDL7(
pcNew.reset(new aiTexture()); pcNew.reset(new aiTexture());
if (!iHeight || !iWidth) if (!iHeight || !iWidth)
{ {
DefaultLogger::get()->warn("Found embedded texture, but its width " ASSIMP_LOG_WARN("Found embedded texture, but its width "
"an height are both 0. Is this a joke?"); "an height are both 0. Is this a joke?");
// generate an empty chess pattern // generate an empty chess pattern

9
code/MS3DLoader.cpp
View File

@ -142,7 +142,7 @@ void MS3DImporter :: ReadComments(StreamReaderLE& stream, std::vector<T>& outp)
stream >> index >> clength; stream >> index >> clength;
if(index >= outp.size()) { if(index >= outp.size()) {
DefaultLogger::get()->warn("MS3D: Invalid index in comment section"); ASSIMP_LOG_WARN("MS3D: Invalid index in comment section");
} }
else if (clength > stream.GetRemainingSize()) { else if (clength > stream.GetRemainingSize()) {
throw DeadlyImportError("MS3D: Failure reading comment, length field is out of range"); throw DeadlyImportError("MS3D: Failure reading comment, length field is out of range");
@ -349,9 +349,6 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
stream.CopyAndAdvance(j.parentName,32); stream.CopyAndAdvance(j.parentName,32);
j.parentName[32] = '\0'; j.parentName[32] = '\0';
// DefaultLogger::get()->debug(j.name);
// DefaultLogger::get()->debug(j.parentName);
ReadVector(stream,j.rotation); ReadVector(stream,j.rotation);
ReadVector(stream,j.position); ReadVector(stream,j.position);
@ -386,7 +383,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
} }
const std::string& s = std::string(reinterpret_cast<char*>(stream.GetPtr()),len); const std::string& s = std::string(reinterpret_cast<char*>(stream.GetPtr()),len);
DefaultLogger::get()->debug("MS3D: Model comment: " + s); ASSIMP_LOG_DEBUG_F("MS3D: Model comment: ", s);
} }
if(stream.GetRemainingSize() > 4 && inrange((stream >> subversion,subversion),1u,3u)) { if(stream.GetRemainingSize() > 4 && inrange((stream >> subversion,subversion),1u,3u)) {
@ -408,7 +405,7 @@ void MS3DImporter::InternReadFile( const std::string& pFile,
// 2 ------------ convert to proper aiXX data structures ----------------------------------- // 2 ------------ convert to proper aiXX data structures -----------------------------------
if (need_default && materials.size()) { if (need_default && materials.size()) {
DefaultLogger::get()->warn("MS3D: Found group with no material assigned, spawning default material"); ASSIMP_LOG_WARN("MS3D: Found group with no material assigned, spawning default material");
// if one of the groups has no material assigned, but there are other // if one of the groups has no material assigned, but there are other
// groups with materials, a default material needs to be added ( // groups with materials, a default material needs to be added (
// scenepreprocessor adds a default material only if nummat==0). // scenepreprocessor adds a default material only if nummat==0).

11
code/MakeVerboseFormat.cpp
View File

@ -65,7 +65,7 @@ MakeVerboseFormatProcess::~MakeVerboseFormatProcess()
void MakeVerboseFormatProcess::Execute( aiScene* pScene) void MakeVerboseFormatProcess::Execute( aiScene* pScene)
{ {
ai_assert(NULL != pScene); ai_assert(NULL != pScene);
DefaultLogger::get()->debug("MakeVerboseFormatProcess begin"); ASSIMP_LOG_DEBUG("MakeVerboseFormatProcess begin");
bool bHas = false; bool bHas = false;
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
@ -73,12 +73,15 @@ void MakeVerboseFormatProcess::Execute( aiScene* pScene)
if( MakeVerboseFormat( pScene->mMeshes[a])) if( MakeVerboseFormat( pScene->mMeshes[a]))
bHas = true; bHas = true;
} }
if (bHas) DefaultLogger::get()->info("MakeVerboseFormatProcess finished. There was much work to do ..."); if (bHas) {
else DefaultLogger::get()->debug("MakeVerboseFormatProcess. There was nothing to do."); ASSIMP_LOG_INFO("MakeVerboseFormatProcess finished. There was much work to do ...");
} else {
ASSIMP_LOG_DEBUG("MakeVerboseFormatProcess. There was nothing to do.");
}
pScene->mFlags &= ~AI_SCENE_FLAGS_NON_VERBOSE_FORMAT; pScene->mFlags &= ~AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh) bool MakeVerboseFormatProcess::MakeVerboseFormat(aiMesh* pcMesh)

6
code/MaterialSystem.cpp
View File

@ -160,7 +160,7 @@ aiReturn aiGetMaterialFloatArray(const aiMaterial* pMat,
break; break;
} }
if ( !IsSpace(*cur) ) { if ( !IsSpace(*cur) ) {
DefaultLogger::get()->error("Material property" + std::string(pKey) + ASSIMP_LOG_ERROR("Material property" + std::string(pKey) +
" is a string; failed to parse a float array out of it."); " is a string; failed to parse a float array out of it.");
return AI_FAILURE; return AI_FAILURE;
} }
@ -233,7 +233,7 @@ aiReturn aiGetMaterialIntegerArray(const aiMaterial* pMat,
break; break;
} }
if(!IsSpace(*cur)) { if(!IsSpace(*cur)) {
DefaultLogger::get()->error("Material property" + std::string(pKey) + ASSIMP_LOG_ERROR("Material property" + std::string(pKey) +
" is a string; failed to parse an integer array out of it."); " is a string; failed to parse an integer array out of it.");
return AI_FAILURE; return AI_FAILURE;
} }
@ -305,7 +305,7 @@ aiReturn aiGetMaterialString(const aiMaterial* pMat,
} }
else { else {
// TODO - implement lexical cast as well // TODO - implement lexical cast as well
DefaultLogger::get()->error("Material property" + std::string(pKey) + ASSIMP_LOG_ERROR("Material property" + std::string(pKey) +
" was found, but is no string" ); " was found, but is no string" );
return AI_FAILURE; return AI_FAILURE;
} }

8
code/NDOLoader.cpp
View File

@ -130,18 +130,18 @@ void NDOImporter::InternReadFile( const std::string& pFile,
unsigned int file_format = 12; unsigned int file_format = 12;
if (!strncmp("1.0",head+6,3)) { if (!strncmp("1.0",head+6,3)) {
file_format = 10; file_format = 10;
DefaultLogger::get()->info("NDO file format is 1.0"); ASSIMP_LOG_INFO("NDO file format is 1.0");
} }
else if (!strncmp("1.1",head+6,3)) { else if (!strncmp("1.1",head+6,3)) {
file_format = 11; file_format = 11;
DefaultLogger::get()->info("NDO file format is 1.1"); ASSIMP_LOG_INFO("NDO file format is 1.1");
} }
else if (!strncmp("1.2",head+6,3)) { else if (!strncmp("1.2",head+6,3)) {
file_format = 12; file_format = 12;
DefaultLogger::get()->info("NDO file format is 1.2"); ASSIMP_LOG_INFO("NDO file format is 1.2");
} }
else { else {
DefaultLogger::get()->warn(std::string("Unrecognized nendo file format version, continuing happily ... :") + (head+6)); ASSIMP_LOG_WARN_F( "Unrecognized nendo file format version, continuing happily ... :", (head+6));
} }
reader.IncPtr(2); /* skip flags */ reader.IncPtr(2); /* skip flags */

41
code/NFFLoader.cpp
View File

@ -125,14 +125,14 @@ const aiImporterDesc* NFFImporter::GetInfo () const
do \ do \
{ \ { \
if (!GetNextLine(buffer,line)) \ if (!GetNextLine(buffer,line)) \
{DefaultLogger::get()->warn("NFF2: Unexpected EOF, can't read next token");break;} \ {ASSIMP_LOG_WARN("NFF2: Unexpected EOF, can't read next token");break;} \
SkipSpaces(line,&sz); \ SkipSpaces(line,&sz); \
} \ } \
while(IsLineEnd(*sz)) while(IsLineEnd(*sz))
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Loads the materail table for the NFF2 file format from an external file // Loads the material table for the NFF2 file format from an external file
void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output, void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
const std::string& path, IOSystem* pIOHandler) const std::string& path, IOSystem* pIOHandler)
{ {
@ -140,7 +140,7 @@ void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
// Check whether we can read from the file // Check whether we can read from the file
if( !file.get()) { if( !file.get()) {
DefaultLogger::get()->error("NFF2: Unable to open material library " + path + "."); ASSIMP_LOG_ERROR("NFF2: Unable to open material library " + path + ".");
return; return;
} }
@ -158,7 +158,7 @@ void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
// The file should start with the magic sequence "mat" // The file should start with the magic sequence "mat"
if (!TokenMatch(buffer,"mat",3)) { if (!TokenMatch(buffer,"mat",3)) {
DefaultLogger::get()->error("NFF2: Not a valid material library " + path + "."); ASSIMP_LOG_ERROR_F("NFF2: Not a valid material library ", path, ".");
return; return;
} }
@ -174,7 +174,7 @@ void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
// 'version' defines the version of the file format // 'version' defines the version of the file format
if (TokenMatch(sz,"version",7)) if (TokenMatch(sz,"version",7))
{ {
DefaultLogger::get()->info("NFF (Sense8) material library file format: " + std::string(sz)); ASSIMP_LOG_INFO_F("NFF (Sense8) material library file format: ", std::string(sz));
} }
// 'matdef' starts a new material in the file // 'matdef' starts a new material in the file
else if (TokenMatch(sz,"matdef",6)) else if (TokenMatch(sz,"matdef",6))
@ -192,8 +192,7 @@ void NFFImporter::LoadNFF2MaterialTable(std::vector<ShadingInfo>& output,
{ {
if (!curShader) if (!curShader)
{ {
DefaultLogger::get()->error(std::string("NFF2 material library: Found element ") + ASSIMP_LOG_ERROR_F("NFF2 material library: Found element ", sz, "but there is no active material");
sz + "but there is no active material");
continue; continue;
} }
} }
@ -308,7 +307,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
SkipSpaces(line,&sz); SkipSpaces(line,&sz);
if (TokenMatch(sz,"version",7)) if (TokenMatch(sz,"version",7))
{ {
DefaultLogger::get()->info("NFF (Sense8) file format: " + std::string(sz)); ASSIMP_LOG_INFO_F("NFF (Sense8) file format: ", sz );
} }
else if (TokenMatch(sz,"viewpos",7)) else if (TokenMatch(sz,"viewpos",7))
{ {
@ -346,7 +345,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
sz3 = sz; sz3 = sz;
while (!IsSpaceOrNewLine(*sz))++sz; while (!IsSpaceOrNewLine(*sz))++sz;
const unsigned int diff = (unsigned int)(sz-sz3); const unsigned int diff = (unsigned int)(sz-sz3);
if (!diff)DefaultLogger::get()->warn("NFF2: Found empty mtable token"); if (!diff)ASSIMP_LOG_WARN("NFF2: Found empty mtable token");
else else
{ {
// The material table has the file extension .mat. // The material table has the file extension .mat.
@ -471,7 +470,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
unsigned int m = ::strtoul10(sz,&sz); unsigned int m = ::strtoul10(sz,&sz);
if (m >= (unsigned int)tempPositions.size()) if (m >= (unsigned int)tempPositions.size())
{ {
DefaultLogger::get()->error("NFF2: Vertex index overflow"); ASSIMP_LOG_ERROR("NFF2: Vertex index overflow");
m= 0; m= 0;
} }
// mesh.vertices.push_back (tempPositions[idx]); // mesh.vertices.push_back (tempPositions[idx]);
@ -551,11 +550,11 @@ void NFFImporter::InternReadFile( const std::string& pFile,
case 'u': case 'u':
case 'U': case 'U':
DefaultLogger::get()->warn("Unsupported NFF2 texture attribute: trans"); ASSIMP_LOG_WARN("Unsupported NFF2 texture attribute: trans");
}; };
if (!sz[1] || '_' != sz[2]) if (!sz[1] || '_' != sz[2])
{ {
DefaultLogger::get()->warn("NFF2: Expected underscore after texture attributes"); ASSIMP_LOG_WARN("NFF2: Expected underscore after texture attributes");
continue; continue;
} }
const char* sz2 = sz+3; const char* sz2 = sz+3;
@ -577,7 +576,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
matIdx = ::strtoul10(sz,&sz); matIdx = ::strtoul10(sz,&sz);
if (matIdx >= materialTable.size()) if (matIdx >= materialTable.size())
{ {
DefaultLogger::get()->error("NFF2: Material index overflow."); ASSIMP_LOG_ERROR("NFF2: Material index overflow.");
matIdx = 0; matIdx = 0;
} }
@ -750,7 +749,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
{ {
if(!GetNextLine(buffer,line)) if(!GetNextLine(buffer,line))
{ {
DefaultLogger::get()->error("NFF: Unexpected EOF was encountered. Patch definition incomplete"); ASSIMP_LOG_ERROR("NFF: Unexpected EOF was encountered. Patch definition incomplete");
continue; continue;
} }
@ -943,7 +942,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
if(!GetNextLine(buffer,line)) if(!GetNextLine(buffer,line))
{ {
DefaultLogger::get()->error("NFF: Unexpected end of file (cone definition not complete)"); ASSIMP_LOG_ERROR("NFF: Unexpected end of file (cone definition not complete)");
break; break;
} }
sz = line; sz = line;
@ -955,7 +954,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
if(!GetNextLine(buffer,line)) if(!GetNextLine(buffer,line))
{ {
DefaultLogger::get()->error("NFF: Unexpected end of file (cone definition not complete)"); ASSIMP_LOG_ERROR("NFF: Unexpected end of file (cone definition not complete)");
break; break;
} }
sz = line; sz = line;
@ -971,7 +970,7 @@ void NFFImporter::InternReadFile( const std::string& pFile,
float f; float f;
if (( f = currentMesh.dir.Length()) < 10e-3f ) if (( f = currentMesh.dir.Length()) < 10e-3f )
{ {
DefaultLogger::get()->error("NFF: Cone height is close to zero"); ASSIMP_LOG_ERROR("NFF: Cone height is close to zero");
continue; continue;
} }
currentMesh.dir /= f; // normalize currentMesh.dir /= f; // normalize
@ -1029,18 +1028,20 @@ void NFFImporter::InternReadFile( const std::string& pFile,
// 'pb' - bezier patch. Not supported yet // 'pb' - bezier patch. Not supported yet
else if (TokenMatch(sz,"pb",2)) else if (TokenMatch(sz,"pb",2))
{ {
DefaultLogger::get()->error("NFF: Encountered unsupported ID: bezier patch"); ASSIMP_LOG_ERROR("NFF: Encountered unsupported ID: bezier patch");
} }
// 'pn' - NURBS. Not supported yet // 'pn' - NURBS. Not supported yet
else if (TokenMatch(sz,"pn",2) || TokenMatch(sz,"pnn",3)) else if (TokenMatch(sz,"pn",2) || TokenMatch(sz,"pnn",3))
{ {
DefaultLogger::get()->error("NFF: Encountered unsupported ID: NURBS"); ASSIMP_LOG_ERROR("NFF: Encountered unsupported ID: NURBS");
} }
// '' - comment // '' - comment
else if ('#' == line[0]) else if ('#' == line[0])
{ {
const char* sz;SkipSpaces(&line[1],&sz); const char* sz;SkipSpaces(&line[1],&sz);
if (!IsLineEnd(*sz))DefaultLogger::get()->info(sz); if (!IsLineEnd(*sz)) {
ASSIMP_LOG_INFO(sz);
}
} }
} }
} }

8
code/OFFLoader.cpp
View File

@ -157,7 +157,7 @@ void OFFImporter::InternReadFile( const std::string& pFile,
{ {
if(!GetNextLine(buffer,line)) if(!GetNextLine(buffer,line))
{ {
DefaultLogger::get()->error("OFF: The number of verts in the header is incorrect"); ASSIMP_LOG_ERROR("OFF: The number of verts in the header is incorrect");
break; break;
} }
aiVector3D& v = tempPositions[i]; aiVector3D& v = tempPositions[i];
@ -175,14 +175,14 @@ void OFFImporter::InternReadFile( const std::string& pFile,
{ {
if(!GetNextLine(buffer,line)) if(!GetNextLine(buffer,line))
{ {
DefaultLogger::get()->error("OFF: The number of faces in the header is incorrect"); ASSIMP_LOG_ERROR("OFF: The number of faces in the header is incorrect");
break; break;
} }
sz = line;SkipSpaces(&sz); sz = line;SkipSpaces(&sz);
faces->mNumIndices = strtoul10(sz,&sz); faces->mNumIndices = strtoul10(sz,&sz);
if(!(faces->mNumIndices) || faces->mNumIndices > 9) if(!(faces->mNumIndices) || faces->mNumIndices > 9)
{ {
DefaultLogger::get()->error("OFF: Faces with zero indices aren't allowed"); ASSIMP_LOG_ERROR("OFF: Faces with zero indices aren't allowed");
--mesh->mNumFaces; --mesh->mNumFaces;
continue; continue;
} }
@ -217,7 +217,7 @@ void OFFImporter::InternReadFile( const std::string& pFile,
idx = strtoul10(sz,&sz); idx = strtoul10(sz,&sz);
if ((idx) >= numVertices) if ((idx) >= numVertices)
{ {
DefaultLogger::get()->error("OFF: Vertex index is out of range"); ASSIMP_LOG_ERROR("OFF: Vertex index is out of range");
idx = numVertices-1; idx = numVertices-1;
} }
faces->mIndices[m] = p++; faces->mIndices[m] = p++;

4
code/ObjFileImporter.cpp
View File

@ -557,7 +557,7 @@ void ObjFileImporter::createMaterials(const ObjFile::Model* pModel, aiScene* pSc
const unsigned int numMaterials = (unsigned int) pModel->m_MaterialLib.size(); const unsigned int numMaterials = (unsigned int) pModel->m_MaterialLib.size();
pScene->mNumMaterials = 0; pScene->mNumMaterials = 0;
if ( pModel->m_MaterialLib.empty() ) { if ( pModel->m_MaterialLib.empty() ) {
DefaultLogger::get()->debug("OBJ: no materials specified"); ASSIMP_LOG_DEBUG("OBJ: no materials specified");
return; return;
} }
@ -591,7 +591,7 @@ void ObjFileImporter::createMaterials(const ObjFile::Model* pModel, aiScene* pSc
break; break;
default: default:
sm = aiShadingMode_Gouraud; sm = aiShadingMode_Gouraud;
DefaultLogger::get()->error("OBJ: unexpected illumination model (0-2 recognized)"); ASSIMP_LOG_ERROR("OBJ: unexpected illumination model (0-2 recognized)");
} }
mat->AddProperty<int>( &sm, 1, AI_MATKEY_SHADING_MODEL); mat->AddProperty<int>( &sm, 1, AI_MATKEY_SHADING_MODEL);

2
code/ObjFileMtlImporter.cpp
View File

@ -366,7 +366,7 @@ void ObjFileMtlImporter::getTexture() {
out = & m_pModel->m_pCurrentMaterial->textureSpecularity; out = & m_pModel->m_pCurrentMaterial->textureSpecularity;
clampIndex = ObjFile::Material::TextureSpecularityType; clampIndex = ObjFile::Material::TextureSpecularityType;
} else { } else {
DefaultLogger::get()->error("OBJ/MTL: Encountered unknown texture type"); ASSIMP_LOG_ERROR("OBJ/MTL: Encountered unknown texture type");
return; return;
} }

20
code/ObjFileParser.cpp
View File

@ -426,7 +426,7 @@ void ObjFileParser::getFace( aiPrimitiveType type ) {
if ( *m_DataIt =='/' ) { if ( *m_DataIt =='/' ) {
if (type == aiPrimitiveType_POINT) { if (type == aiPrimitiveType_POINT) {
DefaultLogger::get()->error("Obj: Separator unexpected in point statement"); ASSIMP_LOG_ERROR("Obj: Separator unexpected in point statement");
} }
if (iPos == 0) { if (iPos == 0) {
//if there are no texture coordinates in the file, but normals //if there are no texture coordinates in the file, but normals
@ -486,7 +486,7 @@ void ObjFileParser::getFace( aiPrimitiveType type ) {
} }
if ( face->m_vertices.empty() ) { if ( face->m_vertices.empty() ) {
DefaultLogger::get()->error("Obj: Ignoring empty face"); ASSIMP_LOG_ERROR("Obj: Ignoring empty face");
// skip line and clean up // skip line and clean up
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine ); m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
delete face; delete face;
@ -556,7 +556,7 @@ void ObjFileParser::getMaterialDesc() {
// This may be the case if the material library is missing. We don't want to lose all // This may be the case if the material library is missing. We don't want to lose all
// materials if that happens, so create a new named material instead of discarding it // materials if that happens, so create a new named material instead of discarding it
// completely. // completely.
DefaultLogger::get()->error("OBJ: failed to locate material " + strName + ", creating new material"); ASSIMP_LOG_ERROR("OBJ: failed to locate material " + strName + ", creating new material");
m_pModel->m_pCurrentMaterial = new ObjFile::Material(); m_pModel->m_pCurrentMaterial = new ObjFile::Material();
m_pModel->m_pCurrentMaterial->MaterialName.Set(strName); m_pModel->m_pCurrentMaterial->MaterialName.Set(strName);
m_pModel->m_MaterialLib.push_back(strName); m_pModel->m_MaterialLib.push_back(strName);
@ -603,7 +603,7 @@ void ObjFileParser::getMaterialLib() {
// Check if directive is valid. // Check if directive is valid.
if ( 0 == strMatName.length() ) { if ( 0 == strMatName.length() ) {
DefaultLogger::get()->warn( "OBJ: no name for material library specified." ); ASSIMP_LOG_WARN( "OBJ: no name for material library specified." );
return; return;
} }
@ -620,12 +620,12 @@ void ObjFileParser::getMaterialLib() {
IOStream *pFile = m_pIO->Open( absName ); IOStream *pFile = m_pIO->Open( absName );
if ( nullptr == pFile ) { if ( nullptr == pFile ) {
DefaultLogger::get()->error("OBJ: Unable to locate material file " + strMatName); ASSIMP_LOG_ERROR("OBJ: Unable to locate material file " + strMatName);
std::string strMatFallbackName = m_originalObjFileName.substr(0, m_originalObjFileName.length() - 3) + "mtl"; std::string strMatFallbackName = m_originalObjFileName.substr(0, m_originalObjFileName.length() - 3) + "mtl";
DefaultLogger::get()->info("OBJ: Opening fallback material file " + strMatFallbackName); ASSIMP_LOG_INFO("OBJ: Opening fallback material file " + strMatFallbackName);
pFile = m_pIO->Open(strMatFallbackName); pFile = m_pIO->Open(strMatFallbackName);
if (!pFile) { if (!pFile) {
DefaultLogger::get()->error("OBJ: Unable to locate fallback material file " + strMatFallbackName); ASSIMP_LOG_ERROR("OBJ: Unable to locate fallback material file " + strMatFallbackName);
m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine); m_DataIt = skipLine<DataArrayIt>(m_DataIt, m_DataItEnd, m_uiLine);
return; return;
} }
@ -660,7 +660,7 @@ void ObjFileParser::getNewMaterial() {
std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( strMat ); std::map<std::string, ObjFile::Material*>::iterator it = m_pModel->m_MaterialMap.find( strMat );
if ( it == m_pModel->m_MaterialMap.end() ) { if ( it == m_pModel->m_MaterialMap.end() ) {
// Show a warning, if material was not found // Show a warning, if material was not found
DefaultLogger::get()->warn("OBJ: Unsupported material requested: " + strMat); ASSIMP_LOG_WARN("OBJ: Unsupported material requested: " + strMat);
m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial; m_pModel->m_pCurrentMaterial = m_pModel->m_pDefaultMaterial;
} else { } else {
// Set new material // Set new material
@ -817,7 +817,7 @@ void ObjFileParser::createMesh( const std::string &meshName )
} }
else else
{ {
DefaultLogger::get()->error("OBJ: No object detected to attach a new mesh instance."); ASSIMP_LOG_ERROR("OBJ: No object detected to attach a new mesh instance.");
} }
} }
@ -851,7 +851,7 @@ bool ObjFileParser::needsNewMesh( const std::string &materialName )
void ObjFileParser::reportErrorTokenInFace() void ObjFileParser::reportErrorTokenInFace()
{ {
m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine ); m_DataIt = skipLine<DataArrayIt>( m_DataIt, m_DataItEnd, m_uiLine );
DefaultLogger::get()->error("OBJ: Not supported token in face description detected"); ASSIMP_LOG_ERROR("OBJ: Not supported token in face description detected");
} }
// ------------------------------------------------------------------- // -------------------------------------------------------------------

44
code/OgreBinarySerializer.cpp
View File

@ -176,7 +176,7 @@ uint16_t OgreBinarySerializer::ReadHeader(bool readLen)
#if (OGRE_BINARY_SERIALIZER_DEBUG == 1) #if (OGRE_BINARY_SERIALIZER_DEBUG == 1)
if (id != HEADER_CHUNK_ID) if (id != HEADER_CHUNK_ID)
{ {
DefaultLogger::get()->debug(Formatter::format() << (assetMode == AM_Mesh ASSIMP_LOG_DEBUG(Formatter::format() << (assetMode == AM_Mesh
? MeshHeaderToString(static_cast<MeshChunkId>(id)) : SkeletonHeaderToString(static_cast<SkeletonChunkId>(id)))); ? MeshHeaderToString(static_cast<MeshChunkId>(id)) : SkeletonHeaderToString(static_cast<SkeletonChunkId>(id))));
} }
#endif #endif
@ -192,7 +192,7 @@ void OgreBinarySerializer::RollbackHeader()
void OgreBinarySerializer::SkipBytes(size_t numBytes) void OgreBinarySerializer::SkipBytes(size_t numBytes)
{ {
#if (OGRE_BINARY_SERIALIZER_DEBUG == 1) #if (OGRE_BINARY_SERIALIZER_DEBUG == 1)
DefaultLogger::get()->debug(Formatter::format() << "Skipping " << numBytes << " bytes"); ASSIMP_LOG_DEBUG_F( "Skipping ", numBytes, " bytes");
#endif #endif
m_reader->IncPtr(numBytes); m_reader->IncPtr(numBytes);
@ -237,8 +237,8 @@ void OgreBinarySerializer::ReadMesh(Mesh *mesh)
{ {
mesh->hasSkeletalAnimations = Read<bool>(); mesh->hasSkeletalAnimations = Read<bool>();
DefaultLogger::get()->debug("Reading Mesh"); ASSIMP_LOG_DEBUG("Reading Mesh");
DefaultLogger::get()->debug(Formatter::format() << " - Skeletal animations: " << (mesh->hasSkeletalAnimations ? "true" : "false")); ASSIMP_LOG_DEBUG_F( " - Skeletal animations: ", mesh->hasSkeletalAnimations ? "true" : "false" );
if (!AtEnd()) if (!AtEnd())
{ {
@ -420,9 +420,9 @@ void OgreBinarySerializer::ReadSubMesh(Mesh *mesh)
submesh->indexData->faceCount = static_cast<uint32_t>(submesh->indexData->count / 3); submesh->indexData->faceCount = static_cast<uint32_t>(submesh->indexData->count / 3);
submesh->indexData->is32bit = Read<bool>(); submesh->indexData->is32bit = Read<bool>();
DefaultLogger::get()->debug(Formatter::format() << "Reading SubMesh " << mesh->subMeshes.size()); ASSIMP_LOG_DEBUG_F( "Reading SubMesh ", mesh->subMeshes.size());
DefaultLogger::get()->debug(Formatter::format() << " - Material: '" << submesh->materialRef << "'"); ASSIMP_LOG_DEBUG_F( " - Material: '", submesh->materialRef, "'");
DefaultLogger::get()->debug(Formatter::format() << " - Uses shared geometry: " << (submesh->usesSharedVertexData ? "true" : "false")); ASSIMP_LOG_DEBUG_F( " - Uses shared geometry: ", submesh->usesSharedVertexData ? "true" : "false" );
// Index buffer // Index buffer
if (submesh->indexData->count > 0) if (submesh->indexData->count > 0)
@ -431,9 +431,9 @@ void OgreBinarySerializer::ReadSubMesh(Mesh *mesh)
uint8_t *indexBuffer = ReadBytes(numBytes); uint8_t *indexBuffer = ReadBytes(numBytes);
submesh->indexData->buffer = MemoryStreamPtr(new Assimp::MemoryIOStream(indexBuffer, numBytes, true)); submesh->indexData->buffer = MemoryStreamPtr(new Assimp::MemoryIOStream(indexBuffer, numBytes, true));
DefaultLogger::get()->debug(Formatter::format() << " - " << submesh->indexData->faceCount ASSIMP_LOG_DEBUG_F( " - ", submesh->indexData->faceCount,
<< " faces from " << submesh->indexData->count << (submesh->indexData->is32bit ? " 32bit" : " 16bit") " faces from ", submesh->indexData->count, (submesh->indexData->is32bit ? " 32bit" : " 16bit"),
<< " indexes of " << numBytes << " bytes"); " indexes of ", numBytes, " bytes");
} }
// Vertex buffer if not referencing the shared geometry // Vertex buffer if not referencing the shared geometry
@ -549,7 +549,7 @@ void OgreBinarySerializer::ReadSubMeshNames(Mesh *mesh)
} }
submesh->name = ReadLine(); submesh->name = ReadLine();
DefaultLogger::get()->debug(Formatter::format() << " - SubMesh " << submesh->index << " name '" << submesh->name << "'"); ASSIMP_LOG_DEBUG_F( " - SubMesh ", submesh->index, " name '", submesh->name, "'");
if (!AtEnd()) if (!AtEnd())
id = ReadHeader(); id = ReadHeader();
@ -563,7 +563,7 @@ void OgreBinarySerializer::ReadGeometry(VertexData *dest)
{ {
dest->count = Read<uint32_t>(); dest->count = Read<uint32_t>();
DefaultLogger::get()->debug(Formatter::format() << " - Reading geometry of " << dest->count << " vertices"); ASSIMP_LOG_DEBUG_F( " - Reading geometry of ", dest->count, " vertices");
if (!AtEnd()) if (!AtEnd())
{ {
@ -620,8 +620,8 @@ void OgreBinarySerializer::ReadGeometryVertexElement(VertexData *dest)
element.offset = Read<uint16_t>(); element.offset = Read<uint16_t>();
element.index = Read<uint16_t>(); element.index = Read<uint16_t>();
DefaultLogger::get()->debug(Formatter::format() << " - Vertex element " << element.SemanticToString() << " of type " ASSIMP_LOG_DEBUG_F( " - Vertex element ", element.SemanticToString(), " of type ",
<< element.TypeToString() << " index=" << element.index << " source=" << element.source); element.TypeToString(), " index=", element.index, " source=", element.source);
dest->vertexElements.push_back(element); dest->vertexElements.push_back(element);
} }
@ -642,7 +642,7 @@ void OgreBinarySerializer::ReadGeometryVertexBuffer(VertexData *dest)
uint8_t *vertexBuffer = ReadBytes(numBytes); uint8_t *vertexBuffer = ReadBytes(numBytes);
dest->vertexBindings[bindIndex] = MemoryStreamPtr(new Assimp::MemoryIOStream(vertexBuffer, numBytes, true)); dest->vertexBindings[bindIndex] = MemoryStreamPtr(new Assimp::MemoryIOStream(vertexBuffer, numBytes, true));
DefaultLogger::get()->debug(Formatter::format() << " - Read vertex buffer for source " << bindIndex << " of " << numBytes << " bytes"); ASSIMP_LOG_DEBUG_F( " - Read vertex buffer for source ", bindIndex, " of ", numBytes, " bytes");
} }
void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/) void OgreBinarySerializer::ReadEdgeList(Mesh * /*mesh*/)
@ -892,13 +892,13 @@ MemoryStreamReaderPtr OgreBinarySerializer::OpenReader(Assimp::IOSystem *pIOHand
{ {
if (!EndsWith(filename, ".skeleton", false)) if (!EndsWith(filename, ".skeleton", false))
{ {
DefaultLogger::get()->error("Imported Mesh is referencing to unsupported '" + filename + "' skeleton file."); ASSIMP_LOG_ERROR_F("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
return MemoryStreamReaderPtr(); return MemoryStreamReaderPtr();
} }
if (!pIOHandler->Exists(filename)) if (!pIOHandler->Exists(filename))
{ {
DefaultLogger::get()->error("Failed to find skeleton file '" + filename + "' that is referenced by imported Mesh."); ASSIMP_LOG_ERROR_F("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
return MemoryStreamReaderPtr(); return MemoryStreamReaderPtr();
} }
@ -925,7 +925,7 @@ void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton)
<< " Supported versions: " << SKELETON_VERSION_1_8 << " and " << SKELETON_VERSION_1_1); << " Supported versions: " << SKELETON_VERSION_1_8 << " and " << SKELETON_VERSION_1_1);
} }
DefaultLogger::get()->debug("Reading Skeleton"); ASSIMP_LOG_DEBUG("Reading Skeleton");
bool firstBone = true; bool firstBone = true;
bool firstAnim = true; bool firstAnim = true;
@ -944,7 +944,7 @@ void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton)
{ {
if (firstBone) if (firstBone)
{ {
DefaultLogger::get()->debug(" - Bones"); ASSIMP_LOG_DEBUG(" - Bones");
firstBone = false; firstBone = false;
} }
@ -960,7 +960,7 @@ void OgreBinarySerializer::ReadSkeleton(Skeleton *skeleton)
{ {
if (firstAnim) if (firstAnim)
{ {
DefaultLogger::get()->debug(" - Animations"); ASSIMP_LOG_DEBUG(" - Animations");
firstAnim = false; firstAnim = false;
} }
@ -1003,7 +1003,7 @@ void OgreBinarySerializer::ReadBone(Skeleton *skeleton)
throw DeadlyImportError(Formatter::format() << "Ogre Skeleton bone indexes not contiguous. Error at bone index " << bone->id); throw DeadlyImportError(Formatter::format() << "Ogre Skeleton bone indexes not contiguous. Error at bone index " << bone->id);
} }
DefaultLogger::get()->debug(Formatter::format() << " " << bone->id << " " << bone->name); ASSIMP_LOG_DEBUG_F( " ", bone->id, " ", bone->name);
skeleton->bones.push_back(bone); skeleton->bones.push_back(bone);
} }
@ -1053,7 +1053,7 @@ void OgreBinarySerializer::ReadSkeletonAnimation(Skeleton *skeleton)
skeleton->animations.push_back(anim); skeleton->animations.push_back(anim);
DefaultLogger::get()->debug(Formatter::format() << " " << anim->name << " (" << anim->length << " sec, " << anim->tracks.size() << " tracks)"); ASSIMP_LOG_DEBUG_F( " ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)");
} }
void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, Animation *dest) void OgreBinarySerializer::ReadSkeletonAnimationTrack(Skeleton * /*skeleton*/, Animation *dest)

37
code/OgreMaterial.cpp
View File

@ -175,18 +175,18 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
if (materialFile) { if (materialFile) {
break; break;
} }
DefaultLogger::get()->debug(Formatter::format() << "Source file for material '" << materialName << "' " << potentialFiles[i] << " does not exist"); ASSIMP_LOG_DEBUG_F( "Source file for material '", materialName, "' ", potentialFiles[i], " does not exist");
} }
if (!materialFile) if (!materialFile)
{ {
DefaultLogger::get()->error(Formatter::format() << "Failed to find source file for material '" << materialName << "'"); ASSIMP_LOG_ERROR_F( "Failed to find source file for material '", materialName, "'");
return 0; return 0;
} }
std::unique_ptr<IOStream> stream(materialFile); std::unique_ptr<IOStream> stream(materialFile);
if (stream->FileSize() == 0) if (stream->FileSize() == 0)
{ {
DefaultLogger::get()->warn(Formatter::format() << "Source file for material '" << materialName << "' is empty (size is 0 bytes)"); ASSIMP_LOG_WARN_F( "Source file for material '", materialName, "' is empty (size is 0 bytes)");
return 0; return 0;
} }
@ -201,7 +201,7 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
ss << &data[0]; ss << &data[0];
} }
DefaultLogger::get()->debug("Reading material '" + materialName + "'"); ASSIMP_LOG_DEBUG_F("Reading material '", materialName, "'");
aiMaterial *material = new aiMaterial(); aiMaterial *material = new aiMaterial();
m_textures.clear(); m_textures.clear();
@ -234,7 +234,6 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
ss >> linePart; ss >> linePart;
if (linePart != materialName) if (linePart != materialName)
{ {
//DefaultLogger::get()->debug(Formatter::format() << "Found material '" << linePart << "' that does not match at index " << ss.tellg());
ss >> linePart; ss >> linePart;
continue; continue;
} }
@ -242,11 +241,11 @@ aiMaterial* OgreImporter::ReadMaterial(const std::string &pFile, Assimp::IOSyste
NextAfterNewLine(ss, linePart); NextAfterNewLine(ss, linePart);
if (linePart != partBlockStart) if (linePart != partBlockStart)
{ {
DefaultLogger::get()->error(Formatter::format() << "Invalid material: block start missing near index " << ss.tellg()); ASSIMP_LOG_ERROR_F( "Invalid material: block start missing near index ", ss.tellg());
return material; return material;
} }
DefaultLogger::get()->debug("material '" + materialName + "'"); ASSIMP_LOG_DEBUG_F("material '", materialName, "'");
while(linePart != partBlockEnd) while(linePart != partBlockEnd)
{ {
@ -350,11 +349,11 @@ bool OgreImporter::ReadTechnique(const std::string &techniqueName, stringstream
if (linePart != partBlockStart) if (linePart != partBlockStart)
{ {
DefaultLogger::get()->error(Formatter::format() << "Invalid material: Technique block start missing near index " << ss.tellg()); ASSIMP_LOG_ERROR_F( "Invalid material: Technique block start missing near index ", ss.tellg());
return false; return false;
} }
DefaultLogger::get()->debug(" technique '" + techniqueName + "'"); ASSIMP_LOG_DEBUG_F(" technique '", techniqueName, "'");
const string partPass = "pass"; const string partPass = "pass";
@ -386,11 +385,11 @@ bool OgreImporter::ReadPass(const std::string &passName, stringstream &ss, aiMat
if (linePart != partBlockStart) if (linePart != partBlockStart)
{ {
DefaultLogger::get()->error(Formatter::format() << "Invalid material: Pass block start missing near index " << ss.tellg()); ASSIMP_LOG_ERROR_F( "Invalid material: Pass block start missing near index ", ss.tellg());
return false; return false;
} }
DefaultLogger::get()->debug(" pass '" + passName + "'"); ASSIMP_LOG_DEBUG_F(" pass '", passName, "'");
const string partAmbient = "ambient"; const string partAmbient = "ambient";
const string partDiffuse = "diffuse"; const string partDiffuse = "diffuse";
@ -417,7 +416,7 @@ bool OgreImporter::ReadPass(const std::string &passName, stringstream &ss, aiMat
ss >> r >> g >> b; ss >> r >> g >> b;
const aiColor3D color(r, g, b); const aiColor3D color(r, g, b);
DefaultLogger::get()->debug(Formatter::format() << " " << linePart << " " << r << " " << g << " " << b); ASSIMP_LOG_DEBUG_F( " ", linePart, " ", r, " ", g, " ", b);
if (linePart == partAmbient) if (linePart == partAmbient)
{ {
@ -452,11 +451,11 @@ bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstr
if (linePart != partBlockStart) if (linePart != partBlockStart)
{ {
DefaultLogger::get()->error(Formatter::format() << "Invalid material: Texture unit block start missing near index " << ss.tellg()); ASSIMP_LOG_ERROR_F( "Invalid material: Texture unit block start missing near index ", ss.tellg());
return false; return false;
} }
DefaultLogger::get()->debug(" texture_unit '" + textureUnitName + "'"); ASSIMP_LOG_DEBUG_F(" texture_unit '", textureUnitName, "'");
const string partTexture = "texture"; const string partTexture = "texture";
const string partTextCoordSet = "tex_coord_set"; const string partTextCoordSet = "tex_coord_set";
@ -491,7 +490,7 @@ bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstr
if (posSuffix != string::npos && posUnderscore != string::npos && posSuffix > posUnderscore) if (posSuffix != string::npos && posUnderscore != string::npos && posSuffix > posUnderscore)
{ {
string identifier = Ogre::ToLower(textureRef.substr(posUnderscore, posSuffix - posUnderscore)); string identifier = Ogre::ToLower(textureRef.substr(posUnderscore, posSuffix - posUnderscore));
DefaultLogger::get()->debug(Formatter::format() << "Detecting texture type from filename postfix '" << identifier << "'"); ASSIMP_LOG_DEBUG_F( "Detecting texture type from filename postfix '", identifier, "'");
if (identifier == "_n" || identifier == "_nrm" || identifier == "_nrml" || identifier == "_normal" || identifier == "_normals" || identifier == "_normalmap") if (identifier == "_n" || identifier == "_nrm" || identifier == "_nrml" || identifier == "_normal" || identifier == "_normals" || identifier == "_normalmap")
{ {
@ -569,20 +568,20 @@ bool OgreImporter::ReadTextureUnit(const std::string &textureUnitName, stringstr
if (textureRef.empty()) if (textureRef.empty())
{ {
DefaultLogger::get()->warn("Texture reference is empty, ignoring texture_unit."); ASSIMP_LOG_WARN("Texture reference is empty, ignoring texture_unit.");
return false; return false;
} }
if (textureType == aiTextureType_NONE) if (textureType == aiTextureType_NONE)
{ {
DefaultLogger::get()->warn("Failed to detect texture type for '" + textureRef + "', ignoring texture_unit."); ASSIMP_LOG_WARN("Failed to detect texture type for '" + textureRef + "', ignoring texture_unit.");
return false; return false;
} }
unsigned int textureTypeIndex = m_textures[textureType]; unsigned int textureTypeIndex = m_textures[textureType];
m_textures[textureType]++; m_textures[textureType]++;
DefaultLogger::get()->debug(Formatter::format() << " texture '" << textureRef << "' type " << textureType ASSIMP_LOG_DEBUG_F( " texture '", textureRef, "' type ", textureType,
<< " index " << textureTypeIndex << " UV " << uvCoord); " index ", textureTypeIndex, " UV ", uvCoord);
aiString assimpTextureRef(textureRef); aiString assimpTextureRef(textureRef);
material->AddProperty(&assimpTextureRef, AI_MATKEY_TEXTURE(textureType, textureTypeIndex)); material->AddProperty(&assimpTextureRef, AI_MATKEY_TEXTURE(textureType, textureTypeIndex));

4
code/OgreStructs.cpp
View File

@ -611,7 +611,7 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
} }
else else
{ {
DefaultLogger::get()->warn(Formatter::format() << "Ogre imported UV0 type " << uv1Element->TypeToString() << " is not compatible with Assimp. Ignoring UV."); ASSIMP_LOG_WARN(Formatter::format() << "Ogre imported UV0 type " << uv1Element->TypeToString() << " is not compatible with Assimp. Ignoring UV.");
uv1 = 0; uv1 = 0;
} }
} }
@ -624,7 +624,7 @@ aiMesh *SubMesh::ConvertToAssimpMesh(Mesh *parent)
} }
else else
{ {
DefaultLogger::get()->warn(Formatter::format() << "Ogre imported UV0 type " << uv2Element->TypeToString() << " is not compatible with Assimp. Ignoring UV."); ASSIMP_LOG_WARN(Formatter::format() << "Ogre imported UV0 type " << uv2Element->TypeToString() << " is not compatible with Assimp. Ignoring UV.");
uv2 = 0; uv2 = 0;
} }
} }

66
code/OgreXmlSerializer.cpp
View File

@ -190,7 +190,7 @@ std::string &OgreXmlSerializer::NextNode()
CurrentNodeName(true); CurrentNodeName(true);
#if (OGRE_XML_SERIALIZER_DEBUG == 1) #if (OGRE_XML_SERIALIZER_DEBUG == 1)
DefaultLogger::get()->debug("<" + m_currentNodeName + ">"); ASSIMP_LOG_DEBUG"<" + m_currentNodeName + ">");
#endif #endif
return m_currentNodeName; return m_currentNodeName;
} }
@ -210,7 +210,7 @@ std::string OgreXmlSerializer::CurrentNodeName(bool forceRead)
std::string &OgreXmlSerializer::SkipCurrentNode() std::string &OgreXmlSerializer::SkipCurrentNode()
{ {
#if (OGRE_XML_SERIALIZER_DEBUG == 1) #if (OGRE_XML_SERIALIZER_DEBUG == 1)
DefaultLogger::get()->debug("Skipping node <" + m_currentNodeName + ">"); ASSIMP_LOG_DEBUG("Skipping node <" + m_currentNodeName + ">");
#endif #endif
for(;;) { for(;;) {
@ -317,7 +317,7 @@ void OgreXmlSerializer::ReadMesh(MeshXml *mesh) {
throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <mesh>"); throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <mesh>");
} }
DefaultLogger::get()->debug("Reading Mesh"); ASSIMP_LOG_DEBUG("Reading Mesh");
NextNode(); NextNode();
@ -351,7 +351,7 @@ void OgreXmlSerializer::ReadMesh(MeshXml *mesh) {
else if (m_currentNodeName == nnSkeletonLink) else if (m_currentNodeName == nnSkeletonLink)
{ {
mesh->skeletonRef = ReadAttribute<std::string>("name"); mesh->skeletonRef = ReadAttribute<std::string>("name");
DefaultLogger::get()->debug("Read skeleton link " + mesh->skeletonRef); ASSIMP_LOG_DEBUG_F("Read skeleton link ", mesh->skeletonRef);
NextNode(); NextNode();
} }
// Assimp incompatible/ignored nodes // Assimp incompatible/ignored nodes
@ -363,7 +363,7 @@ void OgreXmlSerializer::ReadMesh(MeshXml *mesh) {
void OgreXmlSerializer::ReadGeometry(VertexDataXml *dest) void OgreXmlSerializer::ReadGeometry(VertexDataXml *dest)
{ {
dest->count = ReadAttribute<uint32_t>("vertexcount"); dest->count = ReadAttribute<uint32_t>("vertexcount");
DefaultLogger::get()->debug(Formatter::format() << " - Reading geometry of " << dest->count << " vertices"); ASSIMP_LOG_DEBUG_F( " - Reading geometry of ", dest->count, " vertices");
NextNode(); NextNode();
while(m_currentNodeName == nnVertexBuffer) { while(m_currentNodeName == nnVertexBuffer) {
@ -385,22 +385,22 @@ void OgreXmlSerializer::ReadGeometryVertexBuffer(VertexDataXml *dest)
if (positions) if (positions)
{ {
DefaultLogger::get()->debug(" - Contains positions"); ASSIMP_LOG_DEBUG(" - Contains positions");
dest->positions.reserve(dest->count); dest->positions.reserve(dest->count);
} }
if (normals) if (normals)
{ {
DefaultLogger::get()->debug(" - Contains normals"); ASSIMP_LOG_DEBUG(" - Contains normals");
dest->normals.reserve(dest->count); dest->normals.reserve(dest->count);
} }
if (tangents) if (tangents)
{ {
DefaultLogger::get()->debug(" - Contains tangents"); ASSIMP_LOG_DEBUG(" - Contains tangents");
dest->tangents.reserve(dest->count); dest->tangents.reserve(dest->count);
} }
if (uvs > 0) if (uvs > 0)
{ {
DefaultLogger::get()->debug(Formatter::format() << " - Contains " << uvs << " texture coords"); ASSIMP_LOG_DEBUG_F( " - Contains ", uvs, " texture coords");
dest->uvs.resize(uvs); dest->uvs.resize(uvs);
for(size_t i=0, len=dest->uvs.size(); i<len; ++i) { for(size_t i=0, len=dest->uvs.size(); i<len; ++i) {
dest->uvs[i].reserve(dest->count); dest->uvs[i].reserve(dest->count);
@ -508,7 +508,7 @@ void OgreXmlSerializer::ReadGeometryVertexBuffer(VertexDataXml *dest)
} }
} }
if (warn) { if (warn) {
DefaultLogger::get()->warn("Vertex buffer attribute read not implemented for element: " + m_currentNodeName); ASSIMP_LOG_WARN_F("Vertex buffer attribute read not implemented for element: ", m_currentNodeName);
} }
} }
@ -554,9 +554,9 @@ void OgreXmlSerializer::ReadSubMesh(MeshXml *mesh)
submesh->usesSharedVertexData = ReadAttribute<bool>(anUseSharedVertices); submesh->usesSharedVertexData = ReadAttribute<bool>(anUseSharedVertices);
} }
DefaultLogger::get()->debug(Formatter::format() << "Reading SubMesh " << mesh->subMeshes.size()); ASSIMP_LOG_DEBUG_F( "Reading SubMesh ", mesh->subMeshes.size());
DefaultLogger::get()->debug(Formatter::format() << " - Material: '" << submesh->materialRef << "'"); ASSIMP_LOG_DEBUG_F( " - Material: '", submesh->materialRef, "'");
DefaultLogger::get()->debug(Formatter::format() << " - Uses shared geometry: " << (submesh->usesSharedVertexData ? "true" : "false")); ASSIMP_LOG_DEBUG_F( " - Uses shared geometry: ", (submesh->usesSharedVertexData ? "true" : "false"));
// TODO: maybe we have always just 1 faces and 1 geometry and always in this order. this loop will only work correct, when the order // TODO: maybe we have always just 1 faces and 1 geometry and always in this order. this loop will only work correct, when the order
// of faces and geometry changed, and not if we have more than one of one // of faces and geometry changed, and not if we have more than one of one
@ -587,7 +587,7 @@ void OgreXmlSerializer::ReadSubMesh(MeshXml *mesh)
/// @todo Support quads if Ogre even supports them in XML (I'm not sure but I doubt it) /// @todo Support quads if Ogre even supports them in XML (I'm not sure but I doubt it)
if (!quadWarned && HasAttribute(anV4)) { if (!quadWarned && HasAttribute(anV4)) {
DefaultLogger::get()->warn("Submesh <face> has quads with <v4>, only triangles are supported at the moment!"); ASSIMP_LOG_WARN("Submesh <face> has quads with <v4>, only triangles are supported at the moment!");
quadWarned = true; quadWarned = true;
} }
@ -597,31 +597,25 @@ void OgreXmlSerializer::ReadSubMesh(MeshXml *mesh)
NextNode(); NextNode();
} }
if (submesh->indexData->faces.size() == submesh->indexData->faceCount) if (submesh->indexData->faces.size() == submesh->indexData->faceCount) {
{ ASSIMP_LOG_DEBUG_F( " - Faces ", submesh->indexData->faceCount);
DefaultLogger::get()->debug(Formatter::format() << " - Faces " << submesh->indexData->faceCount); } else {
}
else
{
throw DeadlyImportError(Formatter::format() << "Read only " << submesh->indexData->faces.size() << " faces when should have read " << submesh->indexData->faceCount); throw DeadlyImportError(Formatter::format() << "Read only " << submesh->indexData->faces.size() << " faces when should have read " << submesh->indexData->faceCount);
} }
} } else if (m_currentNodeName == nnGeometry) {
else if (m_currentNodeName == nnGeometry)
{
if (submesh->usesSharedVertexData) { if (submesh->usesSharedVertexData) {
throw DeadlyImportError("Found <geometry> in <submesh> when use shared geometry is true. Invalid mesh file."); throw DeadlyImportError("Found <geometry> in <submesh> when use shared geometry is true. Invalid mesh file.");
} }
submesh->vertexData = new VertexDataXml(); submesh->vertexData = new VertexDataXml();
ReadGeometry(submesh->vertexData); ReadGeometry(submesh->vertexData);
} } else if (m_currentNodeName == nnBoneAssignments) {
else if (m_currentNodeName == nnBoneAssignments)
{
ReadBoneAssignments(submesh->vertexData); ReadBoneAssignments(submesh->vertexData);
} }
// Assimp incompatible/ignored nodes // Assimp incompatible/ignored nodes
else else {
SkipCurrentNode(); SkipCurrentNode();
}
} }
submesh->index = static_cast<unsigned int>(mesh->subMeshes.size()); submesh->index = static_cast<unsigned int>(mesh->subMeshes.size());
@ -676,7 +670,7 @@ void OgreXmlSerializer::ReadBoneAssignments(VertexDataXml *dest)
} }
} }
DefaultLogger::get()->debug(Formatter::format() << " - " << dest->boneAssignments.size() << " bone assignments"); ASSIMP_LOG_DEBUG_F( " - ", dest->boneAssignments.size(), " bone assignments");
} }
// Skeleton // Skeleton
@ -731,13 +725,13 @@ XmlReaderPtr OgreXmlSerializer::OpenReader(Assimp::IOSystem *pIOHandler, const s
{ {
if (!EndsWith(filename, ".skeleton.xml", false)) if (!EndsWith(filename, ".skeleton.xml", false))
{ {
DefaultLogger::get()->error("Imported Mesh is referencing to unsupported '" + filename + "' skeleton file."); ASSIMP_LOG_ERROR_F("Imported Mesh is referencing to unsupported '", filename, "' skeleton file.");
return XmlReaderPtr(); return XmlReaderPtr();
} }
if (!pIOHandler->Exists(filename)) if (!pIOHandler->Exists(filename))
{ {
DefaultLogger::get()->error("Failed to find skeleton file '" + filename + "' that is referenced by imported Mesh."); ASSIMP_LOG_ERROR_F("Failed to find skeleton file '", filename, "' that is referenced by imported Mesh.");
return XmlReaderPtr(); return XmlReaderPtr();
} }
@ -760,7 +754,7 @@ void OgreXmlSerializer::ReadSkeleton(Skeleton *skeleton)
throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <skeleton>"); throw DeadlyImportError("Root node is <" + m_currentNodeName + "> expecting <skeleton>");
} }
DefaultLogger::get()->debug("Reading Skeleton"); ASSIMP_LOG_DEBUG("Reading Skeleton");
// Optional blend mode from root node // Optional blend mode from root node
if (HasAttribute("blendmode")) { if (HasAttribute("blendmode")) {
@ -793,7 +787,7 @@ void OgreXmlSerializer::ReadAnimations(Skeleton *skeleton)
throw DeadlyImportError("Cannot read <animations> for a Skeleton without bones"); throw DeadlyImportError("Cannot read <animations> for a Skeleton without bones");
} }
DefaultLogger::get()->debug(" - Animations"); ASSIMP_LOG_DEBUG(" - Animations");
NextNode(); NextNode();
while(m_currentNodeName == nnAnimation) while(m_currentNodeName == nnAnimation)
@ -809,7 +803,7 @@ void OgreXmlSerializer::ReadAnimations(Skeleton *skeleton)
ReadAnimationTracks(anim); ReadAnimationTracks(anim);
skeleton->animations.push_back(anim); skeleton->animations.push_back(anim);
DefaultLogger::get()->debug(Formatter::format() << " " << anim->name << " (" << anim->length << " sec, " << anim->tracks.size() << " tracks)"); ASSIMP_LOG_DEBUG_F( " ", anim->name, " (", anim->length, " sec, ", anim->tracks.size(), " tracks)");
} }
} }
@ -867,7 +861,7 @@ void OgreXmlSerializer::ReadAnimationKeyFrames(Animation *anim, VertexAnimationT
{ {
axis.x = 1.0f; axis.x = 1.0f;
if (angle != 0) { if (angle != 0) {
DefaultLogger::get()->warn("Found invalid a key frame with a zero rotation axis in animation: " + anim->name); ASSIMP_LOG_WARN_F("Found invalid a key frame with a zero rotation axis in animation: ", anim->name);
} }
} }
keyframe.rotation = aiQuaternion(axis, angle); keyframe.rotation = aiQuaternion(axis, angle);
@ -925,7 +919,7 @@ static bool BoneCompare(Bone *a, Bone *b)
void OgreXmlSerializer::ReadBones(Skeleton *skeleton) void OgreXmlSerializer::ReadBones(Skeleton *skeleton)
{ {
DefaultLogger::get()->debug(" - Bones"); ASSIMP_LOG_DEBUG(" - Bones");
NextNode(); NextNode();
while(m_currentNodeName == nnBone) while(m_currentNodeName == nnBone)
@ -994,7 +988,7 @@ void OgreXmlSerializer::ReadBones(Skeleton *skeleton)
for (size_t i=0, len=skeleton->bones.size(); i<len; ++i) for (size_t i=0, len=skeleton->bones.size(); i<len; ++i)
{ {
Bone *b = skeleton->bones[i]; Bone *b = skeleton->bones[i];
DefaultLogger::get()->debug(Formatter::format() << " " << b->id << " " << b->name); ASSIMP_LOG_DEBUG_F( " ", b->id, " ", b->name);
if (b->id != static_cast<uint16_t>(i)) { if (b->id != static_cast<uint16_t>(i)) {
throw DeadlyImportError(Formatter::format() << "Bone ids are not in sequence starting from 0. Missing index " << i); throw DeadlyImportError(Formatter::format() << "Bone ids are not in sequence starting from 0. Missing index " << i);

7
code/OpenGEXImporter.cpp
View File

@ -708,7 +708,7 @@ void OpenGEXImporter::handleMeshNode( ODDLParser::DDLNode *node, aiScene *pScene
} else if ( "quads" == propKey ) { } else if ( "quads" == propKey ) {
m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON; m_currentMesh->mPrimitiveTypes |= aiPrimitiveType_POLYGON;
} else { } else {
DefaultLogger::get()->warn( propKey + " is not supported primitive type." ); ASSIMP_LOG_WARN_F( propKey, " is not supported primitive type." );
} }
} }
} }
@ -1213,12 +1213,11 @@ void OpenGEXImporter::resolveReferences() {
if ( nullptr != m_currentMesh ) { if ( nullptr != m_currentMesh ) {
unsigned int matIdx = static_cast< unsigned int >( m_material2refMap[ name ] ); unsigned int matIdx = static_cast< unsigned int >( m_material2refMap[ name ] );
if ( m_currentMesh->mMaterialIndex != 0 ) { if ( m_currentMesh->mMaterialIndex != 0 ) {
DefaultLogger::get()->warn( "Override of material reference in current mesh by material reference." ); ASSIMP_LOG_WARN( "Override of material reference in current mesh by material reference." );
} }
m_currentMesh->mMaterialIndex = matIdx; m_currentMesh->mMaterialIndex = matIdx;
} else { } else {
DefaultLogger::get()->warn( "Cannot resolve material reference, because no current mesh is there." ); ASSIMP_LOG_WARN( "Cannot resolve material reference, because no current mesh is there." );
} }
} }
} }

10
code/OptimizeGraph.cpp
View File

@ -242,7 +242,7 @@ void OptimizeGraphProcess::CollectNewChildren(aiNode* nd, std::list<aiNode*>& no
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Execute the post-processing step on the given scene // Execute the post-processing step on the given scene
void OptimizeGraphProcess::Execute( aiScene* pScene) { void OptimizeGraphProcess::Execute( aiScene* pScene) {
DefaultLogger::get()->debug("OptimizeGraphProcess begin"); ASSIMP_LOG_DEBUG("OptimizeGraphProcess begin");
nodes_in = nodes_out = count_merged = 0; nodes_in = nodes_out = count_merged = 0;
mScene = pScene; mScene = pScene;
@ -329,12 +329,10 @@ void OptimizeGraphProcess::Execute( aiScene* pScene) {
pScene->mRootNode->mParent = NULL; pScene->mRootNode->mParent = NULL;
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
if ( nodes_in != nodes_out) { if ( nodes_in != nodes_out) {
ASSIMP_LOG_INFO_F("OptimizeGraphProcess finished; Input nodes: ", nodes_in, ", Output nodes: ", nodes_out);
char buf[512]; } else {
::ai_snprintf(buf,512,"OptimizeGraphProcess finished; Input nodes: %u, Output nodes: %u",nodes_in,nodes_out); ASSIMP_LOG_DEBUG("OptimizeGraphProcess finished");
DefaultLogger::get()->info(buf);
} }
else DefaultLogger::get()->debug("OptimizeGraphProcess finished");
} }
meshes.clear(); meshes.clear();
locked.clear(); locked.clear();

10
code/OptimizeMeshes.cpp
View File

@ -107,11 +107,11 @@ void OptimizeMeshesProcess::Execute( aiScene* pScene)
{ {
const unsigned int num_old = pScene->mNumMeshes; const unsigned int num_old = pScene->mNumMeshes;
if (num_old <= 1) { if (num_old <= 1) {
DefaultLogger::get()->debug("Skipping OptimizeMeshesProcess"); ASSIMP_LOG_DEBUG("Skipping OptimizeMeshesProcess");
return; return;
} }
DefaultLogger::get()->debug("OptimizeMeshesProcess begin"); ASSIMP_LOG_DEBUG("OptimizeMeshesProcess begin");
mScene = pScene; mScene = pScene;
// need to clear persistent members from previous runs // need to clear persistent members from previous runs
@ -151,11 +151,9 @@ void OptimizeMeshesProcess::Execute( aiScene* pScene)
std::copy(output.begin(),output.end(),mScene->mMeshes); std::copy(output.begin(),output.end(),mScene->mMeshes);
if (output.size() != num_old) { if (output.size() != num_old) {
char tmp[512]; ASSIMP_LOG_DEBUG_F("OptimizeMeshesProcess finished. Input meshes: ", num_old, ", Output meshes: ", pScene->mNumMeshes);
::ai_snprintf(tmp,512,"OptimizeMeshesProcess finished. Input meshes: %u, Output meshes: %u",num_old,pScene->mNumMeshes);
DefaultLogger::get()->info(tmp);
} else { } else {
DefaultLogger::get()->debug( "OptimizeMeshesProcess finished" ); ASSIMP_LOG_DEBUG( "OptimizeMeshesProcess finished" );
} }
} }

38
code/PlyParser.cpp
View File

@ -97,7 +97,7 @@ PLY::EDataType PLY::Property::ParseDataType(std::vector<char> &buffer) {
} }
if (PLY::EDT_INVALID == eOut) if (PLY::EDT_INVALID == eOut)
{ {
DefaultLogger::get()->info("Found unknown data type in PLY file. This is OK"); ASSIMP_LOG_INFO("Found unknown data type in PLY file. This is OK");
} }
return eOut; return eOut;
@ -229,7 +229,7 @@ PLY::ESemantic PLY::Property::ParseSemantic(std::vector<char> &buffer) {
eOut = PLY::EST_ZNormal; eOut = PLY::EST_ZNormal;
} }
else { else {
DefaultLogger::get()->info("Found unknown property semantic in file. This is ok"); ASSIMP_LOG_INFO("Found unknown property semantic in file. This is ok");
PLY::DOM::SkipLine(buffer); PLY::DOM::SkipLine(buffer);
} }
return eOut; return eOut;
@ -295,7 +295,7 @@ bool PLY::Property::ParseProperty(std::vector<char> &buffer, PLY::Property* pOut
if (PLY::EST_INVALID == pOut->Semantic) if (PLY::EST_INVALID == pOut->Semantic)
{ {
DefaultLogger::get()->info("Found unknown semantic in PLY file. This is OK"); ASSIMP_LOG_INFO("Found unknown semantic in PLY file. This is OK");
std::string(&buffer[0], &buffer[0] + strlen(&buffer[0])); std::string(&buffer[0], &buffer[0] + strlen(&buffer[0]));
} }
@ -514,7 +514,7 @@ bool PLY::DOM::SkipComments(std::vector<char> &buffer)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) { bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, bool isBinary) {
DefaultLogger::get()->debug("PLY::DOM::ParseHeader() begin"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseHeader() begin");
// parse all elements // parse all elements
while (!buffer.empty()) while (!buffer.empty())
@ -543,14 +543,14 @@ bool PLY::DOM::ParseHeader(IOStreamBuffer<char> &streamBuffer, std::vector<char>
if (!isBinary) // it would occur an error, if binary data start with values as space or line end. if (!isBinary) // it would occur an error, if binary data start with values as space or line end.
SkipSpacesAndLineEnd(buffer); SkipSpacesAndLineEnd(buffer);
DefaultLogger::get()->debug("PLY::DOM::ParseHeader() succeeded"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseHeader() succeeded");
return true; return true;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
bool PLY::DOM::ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLYImporter* loader) bool PLY::DOM::ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std::vector<char> &buffer, PLYImporter* loader)
{ {
DefaultLogger::get()->debug("PLY::DOM::ParseElementInstanceLists() begin"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceLists() begin");
alElementData.resize(alElements.size()); alElementData.resize(alElements.size());
std::vector<PLY::Element>::const_iterator i = alElements.begin(); std::vector<PLY::Element>::const_iterator i = alElements.begin();
@ -571,7 +571,7 @@ bool PLY::DOM::ParseElementInstanceLists(IOStreamBuffer<char> &streamBuffer, std
} }
} }
DefaultLogger::get()->debug("PLY::DOM::ParseElementInstanceLists() succeeded"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceLists() succeeded");
return true; return true;
} }
@ -582,7 +582,7 @@ bool PLY::DOM::ParseElementInstanceListsBinary(IOStreamBuffer<char> &streamBuffe
PLYImporter* loader, PLYImporter* loader,
bool p_bBE) bool p_bBE)
{ {
DefaultLogger::get()->debug("PLY::DOM::ParseElementInstanceListsBinary() begin"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() begin");
alElementData.resize(alElements.size()); alElementData.resize(alElements.size());
std::vector<PLY::Element>::const_iterator i = alElements.begin(); std::vector<PLY::Element>::const_iterator i = alElements.begin();
@ -602,7 +602,7 @@ bool PLY::DOM::ParseElementInstanceListsBinary(IOStreamBuffer<char> &streamBuffe
} }
} }
DefaultLogger::get()->debug("PLY::DOM::ParseElementInstanceListsBinary() succeeded"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseElementInstanceListsBinary() succeeded");
return true; return true;
} }
@ -615,11 +615,11 @@ bool PLY::DOM::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, DOM* p_pc
std::vector<char> buffer; std::vector<char> buffer;
streamBuffer.getNextLine(buffer); streamBuffer.getNextLine(buffer);
DefaultLogger::get()->debug("PLY::DOM::ParseInstanceBinary() begin"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() begin");
if (!p_pcOut->ParseHeader(streamBuffer, buffer, true)) if (!p_pcOut->ParseHeader(streamBuffer, buffer, true))
{ {
DefaultLogger::get()->debug("PLY::DOM::ParseInstanceBinary() failure"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() failure");
return false; return false;
} }
@ -628,10 +628,10 @@ bool PLY::DOM::ParseInstanceBinary(IOStreamBuffer<char> &streamBuffer, DOM* p_pc
const char* pCur = (char*)&buffer[0]; const char* pCur = (char*)&buffer[0];
if (!p_pcOut->ParseElementInstanceListsBinary(streamBuffer, buffer, pCur, bufferSize, loader, p_bBE)) if (!p_pcOut->ParseElementInstanceListsBinary(streamBuffer, buffer, pCur, bufferSize, loader, p_bBE))
{ {
DefaultLogger::get()->debug("PLY::DOM::ParseInstanceBinary() failure"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() failure");
return false; return false;
} }
DefaultLogger::get()->debug("PLY::DOM::ParseInstanceBinary() succeeded"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstanceBinary() succeeded");
return true; return true;
} }
@ -644,11 +644,11 @@ bool PLY::DOM::ParseInstance(IOStreamBuffer<char> &streamBuffer, DOM* p_pcOut, P
std::vector<char> buffer; std::vector<char> buffer;
streamBuffer.getNextLine(buffer); streamBuffer.getNextLine(buffer);
DefaultLogger::get()->debug("PLY::DOM::ParseInstance() begin"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() begin");
if (!p_pcOut->ParseHeader(streamBuffer, buffer, false)) if (!p_pcOut->ParseHeader(streamBuffer, buffer, false))
{ {
DefaultLogger::get()->debug("PLY::DOM::ParseInstance() failure"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() failure");
return false; return false;
} }
@ -656,10 +656,10 @@ bool PLY::DOM::ParseInstance(IOStreamBuffer<char> &streamBuffer, DOM* p_pcOut, P
streamBuffer.getNextLine(buffer); streamBuffer.getNextLine(buffer);
if (!p_pcOut->ParseElementInstanceLists(streamBuffer, buffer, loader)) if (!p_pcOut->ParseElementInstanceLists(streamBuffer, buffer, loader))
{ {
DefaultLogger::get()->debug("PLY::DOM::ParseInstance() failure"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() failure");
return false; return false;
} }
DefaultLogger::get()->debug("PLY::DOM::ParseInstance() succeeded"); ASSIMP_LOG_DEBUG("PLY::DOM::ParseInstance() succeeded");
return true; return true;
} }
@ -787,7 +787,7 @@ bool PLY::ElementInstance::ParseInstance(const char* &pCur,
{ {
if (!(PLY::PropertyInstance::ParseInstance(pCur, &(*a), &(*i)))) if (!(PLY::PropertyInstance::ParseInstance(pCur, &(*a), &(*i))))
{ {
DefaultLogger::get()->warn("Unable to parse property instance. " ASSIMP_LOG_WARN("Unable to parse property instance. "
"Skipping this element instance"); "Skipping this element instance");
PLY::PropertyInstance::ValueUnion v = PLY::PropertyInstance::DefaultValue((*a).eType); PLY::PropertyInstance::ValueUnion v = PLY::PropertyInstance::DefaultValue((*a).eType);
@ -819,7 +819,7 @@ bool PLY::ElementInstance::ParseInstanceBinary(
{ {
if (!(PLY::PropertyInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, &(*a), &(*i), p_bBE))) if (!(PLY::PropertyInstance::ParseInstanceBinary(streamBuffer, buffer, pCur, bufferSize, &(*a), &(*i), p_bBE)))
{ {
DefaultLogger::get()->warn("Unable to parse binary property instance. " ASSIMP_LOG_WARN("Unable to parse binary property instance. "
"Skipping this element instance"); "Skipping this element instance");
(*i).avList.push_back(PLY::PropertyInstance::DefaultValue((*a).eType)); (*i).avList.push_back(PLY::PropertyInstance::DefaultValue((*a).eType));

26
code/PretransformVertices.cpp
View File

@ -391,7 +391,7 @@ void PretransformVertices::BuildWCSMeshes(std::vector<aiMesh*>& out, aiMesh** in
} }
if (node->mMeshes[i] < numIn) { if (node->mMeshes[i] < numIn) {
// Worst case. Need to operate on a full copy of the mesh // Worst case. Need to operate on a full copy of the mesh
DefaultLogger::get()->info("PretransformVertices: Copying mesh due to mismatching transforms"); ASSIMP_LOG_INFO("PretransformVertices: Copying mesh due to mismatching transforms");
aiMesh* ntz; aiMesh* ntz;
const unsigned int tmp = mesh->mNumBones; // const unsigned int tmp = mesh->mNumBones; //
@ -441,7 +441,7 @@ void PretransformVertices::BuildMeshRefCountArray(aiNode* nd, unsigned int * ref
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void PretransformVertices::Execute( aiScene* pScene) void PretransformVertices::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("PretransformVerticesProcess begin"); ASSIMP_LOG_DEBUG("PretransformVerticesProcess begin");
// Return immediately if we have no meshes // Return immediately if we have no meshes
if (!pScene->mNumMeshes) if (!pScene->mNumMeshes)
@ -713,22 +713,12 @@ void PretransformVertices::Execute( aiScene* pScene)
} }
// print statistics // print statistics
if (!DefaultLogger::isNullLogger()) if (!DefaultLogger::isNullLogger()) {
{ ASSIMP_LOG_DEBUG("PretransformVerticesProcess finished");
char buffer[4096];
DefaultLogger::get()->debug("PretransformVerticesProcess finished"); ASSIMP_LOG_INFO_F("Removed ", iOldNodes, " nodes and ", iOldAnimationChannels, " animation channels (",
CountNodes(pScene->mRootNode) ," output nodes)" );
::ai_snprintf(buffer,4096,"Removed %u nodes and %u animation channels (%u output nodes)", ASSIMP_LOG_INFO_F("Kept ", pScene->mNumLights, " lights and ", pScene->mNumCameras, " cameras." );
iOldNodes,iOldAnimationChannels,CountNodes(pScene->mRootNode)); ASSIMP_LOG_INFO_F("Moved ", iOldMeshes, " meshes to WCS (number of output meshes: ", pScene->mNumMeshes, ")");
DefaultLogger::get()->info(buffer);
ai_snprintf(buffer, 4096,"Kept %u lights and %u cameras",
pScene->mNumLights,pScene->mNumCameras);
DefaultLogger::get()->info(buffer);
ai_snprintf(buffer, 4096,"Moved %u meshes to WCS (number of output meshes: %u)",
iOldMeshes,pScene->mNumMeshes);
DefaultLogger::get()->info(buffer);
} }
} }

2
code/ProcessHelper.cpp
View File

@ -62,7 +62,7 @@ void ConvertListToStrings(const std::string& in, std::list<std::string>& out)
while (*s != '\'') { while (*s != '\'') {
++s; ++s;
if (*s == '\0') { if (*s == '\0') {
DefaultLogger::get()->error("ConvertListToString: String list is ill-formatted"); ASSIMP_LOG_ERROR("ConvertListToString: String list is ill-formatted");
return; return;
} }
} }

2
code/ProcessHelper.h
View File

@ -348,7 +348,7 @@ class ComputeSpatialSortProcess : public BaseProcess
void Execute( aiScene* pScene) void Execute( aiScene* pScene)
{ {
typedef std::pair<SpatialSort, ai_real> _Type; typedef std::pair<SpatialSort, ai_real> _Type;
DefaultLogger::get()->debug("Generate spatially-sorted vertex cache"); ASSIMP_LOG_DEBUG("Generate spatially-sorted vertex cache");
std::vector<_Type>* p = new std::vector<_Type>(pScene->mNumMeshes); std::vector<_Type>* p = new std::vector<_Type>(pScene->mNumMeshes);
std::vector<_Type>::iterator it = p->begin(); std::vector<_Type>::iterator it = p->begin();

10
code/Q3DLoader.cpp
View File

@ -125,7 +125,7 @@ void Q3DImporter::InternReadFile( const std::string& pFile,
} }
// Print the file format version // Print the file format version
DefaultLogger::get()->info("Quick3D File format version: " + ASSIMP_LOG_INFO_F("Quick3D File format version: ",
std::string(&((const char*)stream.GetPtr())[8],2)); std::string(&((const char*)stream.GetPtr())[8],2));
// ... an store it // ... an store it
@ -413,7 +413,7 @@ outer:
// If we have no materials loaded - generate a default mat // If we have no materials loaded - generate a default mat
if (materials.empty()) if (materials.empty())
{ {
DefaultLogger::get()->info("Quick3D: No material found, generating one"); ASSIMP_LOG_INFO("Quick3D: No material found, generating one");
materials.push_back(Material()); materials.push_back(Material());
materials.back().diffuse = fgColor ; materials.back().diffuse = fgColor ;
} }
@ -433,7 +433,7 @@ outer:
{ {
if ((*fit).mat >= materials.size()) if ((*fit).mat >= materials.size())
{ {
DefaultLogger::get()->warn("Quick3D: Material index overflow"); ASSIMP_LOG_WARN("Quick3D: Material index overflow");
(*fit).mat = 0; (*fit).mat = 0;
} }
if (fidx[(*fit).mat].empty())++pScene->mNumMeshes; if (fidx[(*fit).mat].empty())++pScene->mNumMeshes;
@ -528,7 +528,7 @@ outer:
{ {
if (face.indices[n] >= m.verts.size()) if (face.indices[n] >= m.verts.size())
{ {
DefaultLogger::get()->warn("Quick3D: Vertex index overflow"); ASSIMP_LOG_WARN("Quick3D: Vertex index overflow");
face.indices[n] = 0; face.indices[n] = 0;
} }
@ -561,7 +561,7 @@ outer:
{ {
if (face.uvindices[n] >= m.uv.size()) if (face.uvindices[n] >= m.uv.size())
{ {
DefaultLogger::get()->warn("Quick3D: Texture coordinate index overflow"); ASSIMP_LOG_WARN("Quick3D: Texture coordinate index overflow");
face.uvindices[n] = 0; face.uvindices[n] = 0;
} }
*uv = m.uv[face.uvindices[n]]; *uv = m.uv[face.uvindices[n]];

2
code/RawLoader.cpp
View File

@ -160,7 +160,7 @@ void RAWImporter::InternReadFile( const std::string& pFile,
} }
if (num != 12 && num != 9) if (num != 12 && num != 9)
{ {
DefaultLogger::get()->error("A line may have either 9 or 12 floats and an optional texture"); ASSIMP_LOG_ERROR("A line may have either 9 or 12 floats and an optional texture");
continue; continue;
} }

12
code/RemoveRedundantMaterials.cpp
View File

@ -87,7 +87,7 @@ void RemoveRedundantMatsProcess::SetupProperties(const Importer* pImp)
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void RemoveRedundantMatsProcess::Execute( aiScene* pScene) void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("RemoveRedundantMatsProcess begin"); ASSIMP_LOG_DEBUG("RemoveRedundantMatsProcess begin");
unsigned int redundantRemoved = 0, unreferencedRemoved = 0; unsigned int redundantRemoved = 0, unreferencedRemoved = 0;
if (pScene->mNumMaterials) if (pScene->mNumMaterials)
@ -122,7 +122,7 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
// Keep this material even if no mesh references it // Keep this material even if no mesh references it
abReferenced[i] = true; abReferenced[i] = true;
DefaultLogger::get()->debug(std::string("Found positive match in exclusion list: \'") + name.data + "\'"); ASSIMP_LOG_DEBUG_F( "Found positive match in exclusion list: \'", name.data, "\'");
} }
} }
} }
@ -211,13 +211,11 @@ void RemoveRedundantMatsProcess::Execute( aiScene* pScene)
} }
if (redundantRemoved == 0 && unreferencedRemoved == 0) if (redundantRemoved == 0 && unreferencedRemoved == 0)
{ {
DefaultLogger::get()->debug("RemoveRedundantMatsProcess finished "); ASSIMP_LOG_DEBUG("RemoveRedundantMatsProcess finished ");
} }
else else
{ {
char szBuffer[128]; // should be sufficiently large ASSIMP_LOG_INFO_F("RemoveRedundantMatsProcess finished. Removed ", redundantRemoved, " redundant and ",
::ai_snprintf(szBuffer,128,"RemoveRedundantMatsProcess finished. Removed %u redundant and %u unused materials.", unreferencedRemoved, " unused materials.");
redundantRemoved,unreferencedRemoved);
DefaultLogger::get()->info(szBuffer);
} }
} }

13
code/RemoveVCProcess.cpp
View File

@ -145,7 +145,7 @@ bool UpdateNodeGraph(aiNode* node,std::list<aiNode*>& childsOfParent,bool root)
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void RemoveVCProcess::Execute( aiScene* pScene) void RemoveVCProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("RemoveVCProcess begin"); ASSIMP_LOG_DEBUG("RemoveVCProcess begin");
bool bHas = false; //,bMasked = false; bool bHas = false; //,bMasked = false;
mScene = pScene; mScene = pScene;
@ -224,15 +224,18 @@ void RemoveVCProcess::Execute( aiScene* pScene)
if (!pScene->mNumMeshes || !pScene->mNumMaterials) if (!pScene->mNumMeshes || !pScene->mNumMaterials)
{ {
pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE; pScene->mFlags |= AI_SCENE_FLAGS_INCOMPLETE;
DefaultLogger::get()->debug("Setting AI_SCENE_FLAGS_INCOMPLETE flag"); ASSIMP_LOG_DEBUG("Setting AI_SCENE_FLAGS_INCOMPLETE flag");
// If we have no meshes anymore we should also clear another flag ... // If we have no meshes anymore we should also clear another flag ...
if (!pScene->mNumMeshes) if (!pScene->mNumMeshes)
pScene->mFlags &= ~AI_SCENE_FLAGS_NON_VERBOSE_FORMAT; pScene->mFlags &= ~AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
} }
if (bHas)DefaultLogger::get()->info("RemoveVCProcess finished. Data structure cleanup has been done."); if (bHas) {
else DefaultLogger::get()->debug("RemoveVCProcess finished. Nothing to be done ..."); ASSIMP_LOG_INFO("RemoveVCProcess finished. Data structure cleanup has been done.");
} else {
ASSIMP_LOG_DEBUG("RemoveVCProcess finished. Nothing to be done ...");
}
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -242,7 +245,7 @@ void RemoveVCProcess::SetupProperties(const Importer* pImp)
configDeleteFlags = pImp->GetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS,0x0); configDeleteFlags = pImp->GetPropertyInteger(AI_CONFIG_PP_RVC_FLAGS,0x0);
if (!configDeleteFlags) if (!configDeleteFlags)
{ {
DefaultLogger::get()->warn("RemoveVCProcess: AI_CONFIG_PP_RVC_FLAGS is zero."); ASSIMP_LOG_WARN("RemoveVCProcess: AI_CONFIG_PP_RVC_FLAGS is zero.");
} }
} }

6
code/SIBImporter.cpp
View File

@ -150,7 +150,7 @@ static SIBChunk ReadChunk(StreamReaderLE* stream)
chunk.Tag = stream->GetU4(); chunk.Tag = stream->GetU4();
chunk.Size = stream->GetU4(); chunk.Size = stream->GetU4();
if (chunk.Size > stream->GetRemainingSizeToLimit()) if (chunk.Size > stream->GetRemainingSizeToLimit())
DefaultLogger::get()->error("SIB: Chunk overflow"); ASSIMP_LOG_ERROR("SIB: Chunk overflow");
ByteSwap::Swap4(&chunk.Tag); ByteSwap::Swap4(&chunk.Tag);
return chunk; return chunk;
} }
@ -173,7 +173,7 @@ static void UnknownChunk(StreamReaderLE* /*stream*/, const SIBChunk& chunk)
static_cast<char>(chunk.Tag & 0xff), '\0' static_cast<char>(chunk.Tag & 0xff), '\0'
}; };
DefaultLogger::get()->warn((Formatter::format(), "SIB: Skipping unknown '",temp,"' chunk.")); ASSIMP_LOG_WARN((Formatter::format(), "SIB: Skipping unknown '",temp,"' chunk."));
} }
// Reads a UTF-16LE string and returns it at UTF-8. // Reads a UTF-16LE string and returns it at UTF-8.
@ -589,7 +589,7 @@ static void ReadShape(SIB* sib, StreamReaderLE* stream)
if (mtl >= meshes.size()) if (mtl >= meshes.size())
{ {
DefaultLogger::get()->error("SIB: Face material index is invalid."); ASSIMP_LOG_ERROR("SIB: Face material index is invalid.");
mtl = 0; mtl = 0;
} }

14
code/SMDLoader.cpp
View File

@ -182,7 +182,7 @@ void SMDImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
{ {
if (!(*i).mName.length()) if (!(*i).mName.length())
{ {
DefaultLogger::get()->warn("SMD: Not all bones have been initialized"); ASSIMP_LOG_WARN("SMD: Not all bones have been initialized");
break; break;
} }
} }
@ -230,7 +230,7 @@ void SMDImporter::LogWarning(const char* msg)
char szTemp[1024]; char szTemp[1024];
ai_assert(strlen(msg) < 1000); ai_assert(strlen(msg) < 1000);
ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,msg); ai_snprintf(szTemp,1024,"Line %u: %s",iLineNumber,msg);
DefaultLogger::get()->warn(szTemp); ASSIMP_LOG_WARN(szTemp);
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -286,7 +286,7 @@ void SMDImporter::CreateOutputMeshes()
if (UINT_MAX == (*iFace).iTexture)aaiFaces[(*iFace).iTexture].push_back( 0 ); if (UINT_MAX == (*iFace).iTexture)aaiFaces[(*iFace).iTexture].push_back( 0 );
else if ((*iFace).iTexture >= aszTextures.size()) else if ((*iFace).iTexture >= aszTextures.size())
{ {
DefaultLogger::get()->error("[SMD/VTA] Material index overflow in face"); ASSIMP_LOG_INFO("[SMD/VTA] Material index overflow in face");
aaiFaces[(*iFace).iTexture].push_back((unsigned int)aszTextures.size()-1); aaiFaces[(*iFace).iTexture].push_back((unsigned int)aszTextures.size()-1);
} }
else aaiFaces[(*iFace).iTexture].push_back(iNum); else aaiFaces[(*iFace).iTexture].push_back(iNum);
@ -366,7 +366,7 @@ void SMDImporter::CreateOutputMeshes()
if (pairval.first >= asBones.size() || if (pairval.first >= asBones.size() ||
pairval.first == face.avVertices[iVert].iParentNode) pairval.first == face.avVertices[iVert].iParentNode)
{ {
DefaultLogger::get()->error("[SMD/VTA] Bone index overflow. " ASSIMP_LOG_ERROR("[SMD/VTA] Bone index overflow. "
"The bone index will be ignored, the weight will be assigned " "The bone index will be ignored, the weight will be assigned "
"to the vertex' parent node"); "to the vertex' parent node");
continue; continue;
@ -387,7 +387,7 @@ void SMDImporter::CreateOutputMeshes()
{ {
if (face.avVertices[iVert].iParentNode >= asBones.size()) if (face.avVertices[iVert].iParentNode >= asBones.size())
{ {
DefaultLogger::get()->error("[SMD/VTA] Bone index overflow. " ASSIMP_LOG_ERROR("[SMD/VTA] Bone index overflow. "
"The index of the vertex parent bone is invalid. " "The index of the vertex parent bone is invalid. "
"The remaining weights will be normalized to 1.0"); "The remaining weights will be normalized to 1.0");
@ -715,7 +715,7 @@ void SMDImporter::ParseFile()
if(!SkipSpaces(szCurrent,&szCurrent)) break; if(!SkipSpaces(szCurrent,&szCurrent)) break;
if (1 != strtoul10(szCurrent,&szCurrent)) if (1 != strtoul10(szCurrent,&szCurrent))
{ {
DefaultLogger::get()->warn("SMD.version is not 1. This " ASSIMP_LOG_WARN("SMD.version is not 1. This "
"file format is not known. Continuing happily ..."); "file format is not known. Continuing happily ...");
} }
continue; continue;
@ -953,7 +953,7 @@ void SMDImporter::ParseSkeletonElement(const char* szCurrent,
unsigned int iBone = 0; unsigned int iBone = 0;
if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone)) if(!ParseUnsignedInt(szCurrent,&szCurrent,iBone))
{ {
DefaultLogger::get()->error("Unexpected EOF/EOL while parsing bone index"); ASSIMP_LOG_ERROR("Unexpected EOF/EOL while parsing bone index");
SMDI_PARSE_RETURN; SMDI_PARSE_RETURN;
} }
if (iBone >= asBones.size()) if (iBone >= asBones.size())

4
code/STEPFile.h
View File

@ -776,10 +776,10 @@ namespace STEP {
// XXX is this really how the EXPRESS notation ([?:3],[1:3]) is intended? // XXX is this really how the EXPRESS notation ([?:3],[1:3]) is intended?
if (max_cnt && inp->GetSize() > max_cnt) { if (max_cnt && inp->GetSize() > max_cnt) {
DefaultLogger::get()->warn("too many aggregate elements"); ASSIMP_LOG_WARN("too many aggregate elements");
} }
else if (inp->GetSize() < min_cnt) { else if (inp->GetSize() < min_cnt) {
DefaultLogger::get()->warn("too few aggregate elements"); ASSIMP_LOG_WARN("too few aggregate elements");
} }
out.reserve(inp->GetSize()); out.reserve(inp->GetSize());

12
code/STLLoader.cpp
View File

@ -286,14 +286,14 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
if(!SkipSpacesAndLineEnd(&sz)) if(!SkipSpacesAndLineEnd(&sz))
{ {
// seems we're finished although there was no end marker // seems we're finished although there was no end marker
DefaultLogger::get()->warn("STL: unexpected EOF. \'endsolid\' keyword was expected"); ASSIMP_LOG_WARN("STL: unexpected EOF. \'endsolid\' keyword was expected");
break; break;
} }
// facet normal -0.13 -0.13 -0.98 // facet normal -0.13 -0.13 -0.98
if (!strncmp(sz,"facet",5) && IsSpaceOrNewLine(*(sz+5)) && *(sz + 5) != '\0') { if (!strncmp(sz,"facet",5) && IsSpaceOrNewLine(*(sz+5)) && *(sz + 5) != '\0') {
if (faceVertexCounter != 3) { if (faceVertexCounter != 3) {
DefaultLogger::get()->warn("STL: A new facet begins but the old is not yet complete"); ASSIMP_LOG_WARN("STL: A new facet begins but the old is not yet complete");
} }
faceVertexCounter = 0; faceVertexCounter = 0;
normalBuffer.push_back(aiVector3D()); normalBuffer.push_back(aiVector3D());
@ -302,7 +302,7 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
sz += 6; sz += 6;
SkipSpaces(&sz); SkipSpaces(&sz);
if (strncmp(sz,"normal",6)) { if (strncmp(sz,"normal",6)) {
DefaultLogger::get()->warn("STL: a facet normal vector was expected but not found"); ASSIMP_LOG_WARN("STL: a facet normal vector was expected but not found");
} else { } else {
if (sz[6] == '\0') { if (sz[6] == '\0') {
throw DeadlyImportError("STL: unexpected EOF while parsing facet"); throw DeadlyImportError("STL: unexpected EOF while parsing facet");
@ -319,7 +319,7 @@ void STLImporter::LoadASCIIFile( aiNode *root ) {
} }
} else if (!strncmp(sz,"vertex",6) && ::IsSpaceOrNewLine(*(sz+6))) { // vertex 1.50000 1.50000 0.00000 } else if (!strncmp(sz,"vertex",6) && ::IsSpaceOrNewLine(*(sz+6))) { // vertex 1.50000 1.50000 0.00000
if (faceVertexCounter >= 3) { if (faceVertexCounter >= 3) {
DefaultLogger::get()->error("STL: a facet with more than 3 vertices has been found"); ASSIMP_LOG_ERROR("STL: a facet with more than 3 vertices has been found");
++sz; ++sz;
} else { } else {
if (sz[6] == '\0') { if (sz[6] == '\0') {
@ -418,7 +418,7 @@ bool STLImporter::LoadBinaryFile()
// read the default vertex color for facets // read the default vertex color for facets
bIsMaterialise = true; bIsMaterialise = true;
DefaultLogger::get()->info("STL: Taking code path for Materialise files"); ASSIMP_LOG_INFO("STL: Taking code path for Materialise files");
const ai_real invByte = (ai_real)1.0 / ( ai_real )255.0; const ai_real invByte = (ai_real)1.0 / ( ai_real )255.0;
clrColorDefault.r = (*sz2++) * invByte; clrColorDefault.r = (*sz2++) * invByte;
clrColorDefault.g = (*sz2++) * invByte; clrColorDefault.g = (*sz2++) * invByte;
@ -500,7 +500,7 @@ bool STLImporter::LoadBinaryFile()
*pMesh->mColors[0]++ = this->clrColorDefault; *pMesh->mColors[0]++ = this->clrColorDefault;
pMesh->mColors[0] -= pMesh->mNumVertices; pMesh->mColors[0] -= pMesh->mNumVertices;
DefaultLogger::get()->info("STL: Mesh has vertex colors"); ASSIMP_LOG_INFO("STL: Mesh has vertex colors");
} }
aiColor4D* clr = &pMesh->mColors[0][i*3]; aiColor4D* clr = &pMesh->mColors[0][i*3];
clr->a = 1.0; clr->a = 1.0;

18
code/SceneCombiner.cpp
View File

@ -75,7 +75,7 @@ void PrefixString(aiString& string,const char* prefix, unsigned int len) {
return; return;
if (len+string.length>=MAXLEN-1) { if (len+string.length>=MAXLEN-1) {
DefaultLogger::get()->debug("Can't add an unique prefix because the string is too long"); ASSIMP_LOG_DEBUG("Can't add an unique prefix because the string is too long");
ai_assert(false); ai_assert(false);
return; return;
} }
@ -622,8 +622,8 @@ void SceneCombiner::MergeScenes(aiScene** _dest, aiScene* master, std::vector<At
} }
} }
if (!(*it).resolved) { if (!(*it).resolved) {
DefaultLogger::get()->error(std::string("SceneCombiner: Failed to resolve attachment ") ASSIMP_LOG_ERROR_F( "SceneCombiner: Failed to resolve attachment ", (*it).node->mName.data,
+ (*it).node->mName.data + " " + (*it).attachToNode->mName.data); " ", (*it).attachToNode->mName.data );
} }
} }
} }
@ -727,7 +727,7 @@ void SceneCombiner::MergeBones(aiMesh* out,std::vector<aiMesh*>::const_iterator
// NOTE: different offset matrices for bones with equal names // NOTE: different offset matrices for bones with equal names
// are - at the moment - not handled correctly. // are - at the moment - not handled correctly.
if (wmit != (*it).pSrcBones.begin() && pc->mOffsetMatrix != (*wmit).first->mOffsetMatrix) { if (wmit != (*it).pSrcBones.begin() && pc->mOffsetMatrix != (*wmit).first->mOffsetMatrix) {
DefaultLogger::get()->warn("Bones with equal names but different offset matrices can't be joined at the moment"); ASSIMP_LOG_WARN("Bones with equal names but different offset matrices can't be joined at the moment");
continue; continue;
} }
pc->mOffsetMatrix = (*wmit).first->mOffsetMatrix; pc->mOffsetMatrix = (*wmit).first->mOffsetMatrix;
@ -796,7 +796,7 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
if ((*it)->mVertices) { if ((*it)->mVertices) {
::memcpy(pv2,(*it)->mVertices,(*it)->mNumVertices*sizeof(aiVector3D)); ::memcpy(pv2,(*it)->mVertices,(*it)->mNumVertices*sizeof(aiVector3D));
} }
else DefaultLogger::get()->warn("JoinMeshes: Positions expected but input mesh contains no positions"); else ASSIMP_LOG_WARN("JoinMeshes: Positions expected but input mesh contains no positions");
pv2 += (*it)->mNumVertices; pv2 += (*it)->mNumVertices;
} }
} }
@ -808,7 +808,7 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
if ((*it)->mNormals) { if ((*it)->mNormals) {
::memcpy(pv2,(*it)->mNormals,(*it)->mNumVertices*sizeof(aiVector3D)); ::memcpy(pv2,(*it)->mNormals,(*it)->mNumVertices*sizeof(aiVector3D));
} else { } else {
DefaultLogger::get()->warn( "JoinMeshes: Normals expected but input mesh contains no normals" ); ASSIMP_LOG_WARN( "JoinMeshes: Normals expected but input mesh contains no normals" );
} }
pv2 += (*it)->mNumVertices; pv2 += (*it)->mNumVertices;
} }
@ -824,7 +824,7 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
::memcpy(pv2, (*it)->mTangents, (*it)->mNumVertices*sizeof(aiVector3D)); ::memcpy(pv2, (*it)->mTangents, (*it)->mNumVertices*sizeof(aiVector3D));
::memcpy(pv2b,(*it)->mBitangents,(*it)->mNumVertices*sizeof(aiVector3D)); ::memcpy(pv2b,(*it)->mBitangents,(*it)->mNumVertices*sizeof(aiVector3D));
} else { } else {
DefaultLogger::get()->warn( "JoinMeshes: Tangents expected but input mesh contains no tangents" ); ASSIMP_LOG_WARN( "JoinMeshes: Tangents expected but input mesh contains no tangents" );
} }
pv2 += (*it)->mNumVertices; pv2 += (*it)->mNumVertices;
pv2b += (*it)->mNumVertices; pv2b += (*it)->mNumVertices;
@ -840,7 +840,7 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
if ((*it)->mTextureCoords[n]) { if ((*it)->mTextureCoords[n]) {
::memcpy(pv2,(*it)->mTextureCoords[n],(*it)->mNumVertices*sizeof(aiVector3D)); ::memcpy(pv2,(*it)->mTextureCoords[n],(*it)->mNumVertices*sizeof(aiVector3D));
} else { } else {
DefaultLogger::get()->warn( "JoinMeshes: UVs expected but input mesh contains no UVs" ); ASSIMP_LOG_WARN( "JoinMeshes: UVs expected but input mesh contains no UVs" );
} }
pv2 += (*it)->mNumVertices; pv2 += (*it)->mNumVertices;
} }
@ -854,7 +854,7 @@ void SceneCombiner::MergeMeshes(aiMesh** _out, unsigned int /*flags*/,
if ((*it)->mColors[n]) { if ((*it)->mColors[n]) {
::memcpy(pv2,(*it)->mColors[n],(*it)->mNumVertices*sizeof(aiColor4D)); ::memcpy(pv2,(*it)->mColors[n],(*it)->mNumVertices*sizeof(aiColor4D));
} else { } else {
DefaultLogger::get()->warn( "JoinMeshes: VCs expected but input mesh contains no VCs" ); ASSIMP_LOG_WARN( "JoinMeshes: VCs expected but input mesh contains no VCs" );
} }
pv2 += (*it)->mNumVertices; pv2 += (*it)->mNumVertices;
} }

12
code/ScenePreprocessor.cpp
View File

@ -81,7 +81,7 @@ void ScenePreprocessor::ProcessScene ()
name.Set(AI_DEFAULT_MATERIAL_NAME); name.Set(AI_DEFAULT_MATERIAL_NAME);
helper->AddProperty(&name,AI_MATKEY_NAME); helper->AddProperty(&name,AI_MATKEY_NAME);
DefaultLogger::get()->debug("ScenePreprocessor: Adding default material \'" AI_DEFAULT_MATERIAL_NAME "\'"); ASSIMP_LOG_DEBUG("ScenePreprocessor: Adding default material \'" AI_DEFAULT_MATERIAL_NAME "\'");
for (unsigned int i = 0; i < scene->mNumMeshes;++i) { for (unsigned int i = 0; i < scene->mNumMeshes;++i) {
scene->mMeshes[i]->mMaterialIndex = scene->mNumMaterials; scene->mMeshes[i]->mMaterialIndex = scene->mNumMaterials;
@ -122,7 +122,7 @@ void ScenePreprocessor::ProcessMesh (aiMesh* mesh)
break; break;
} }
if (p == end) { if (p == end) {
DefaultLogger::get()->warn("ScenePreprocessor: UVs are declared to be 3D but they're obviously not. Reverting to 2D."); ASSIMP_LOG_WARN("ScenePreprocessor: UVs are declared to be 3D but they're obviously not. Reverting to 2D.");
mesh->mNumUVComponents[i] = 2; mesh->mNumUVComponents[i] = 2;
} }
} }
@ -224,7 +224,7 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
q.mTime = 0.; q.mTime = 0.;
q.mValue = rotation; q.mValue = rotation;
DefaultLogger::get()->debug("ScenePreprocessor: Dummy rotation track has been generated"); ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy rotation track has been generated");
} }
// No scaling keys? Generate a dummy track // No scaling keys? Generate a dummy track
@ -236,7 +236,7 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
q.mTime = 0.; q.mTime = 0.;
q.mValue = scaling; q.mValue = scaling;
DefaultLogger::get()->debug("ScenePreprocessor: Dummy scaling track has been generated"); ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy scaling track has been generated");
} }
// No position keys? Generate a dummy track // No position keys? Generate a dummy track
@ -248,14 +248,14 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
q.mTime = 0.; q.mTime = 0.;
q.mValue = position; q.mValue = position;
DefaultLogger::get()->debug("ScenePreprocessor: Dummy position track has been generated"); ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy position track has been generated");
} }
} }
} }
} }
if (anim->mDuration == -1.) { if (anim->mDuration == -1.) {
DefaultLogger::get()->debug("ScenePreprocessor: Setting animation duration"); ASSIMP_LOG_DEBUG("ScenePreprocessor: Setting animation duration");
anim->mDuration = last - std::min( first, 0. ); anim->mDuration = last - std::min( first, 0. );
} }
} }

8
code/SortByPTypeProcess.cpp
View File

@ -137,11 +137,11 @@ void SortByPTypeProcess::Execute( aiScene* pScene)
{ {
if (!pScene->mNumMeshes) if (!pScene->mNumMeshes)
{ {
DefaultLogger::get()->debug("SortByPTypeProcess skipped, there are no meshes"); ASSIMP_LOG_DEBUG("SortByPTypeProcess skipped, there are no meshes");
return; return;
} }
DefaultLogger::get()->debug("SortByPTypeProcess begin"); ASSIMP_LOG_DEBUG("SortByPTypeProcess begin");
unsigned int aiNumMeshesPerPType[4] = {0,0,0,0}; unsigned int aiNumMeshesPerPType[4] = {0,0,0,0};
@ -404,8 +404,8 @@ void SortByPTypeProcess::Execute( aiScene* pScene)
aiNumMeshesPerPType[1], ((configRemoveMeshes & aiPrimitiveType_LINE) ? "X" : ""), aiNumMeshesPerPType[1], ((configRemoveMeshes & aiPrimitiveType_LINE) ? "X" : ""),
aiNumMeshesPerPType[2], ((configRemoveMeshes & aiPrimitiveType_TRIANGLE) ? "X" : ""), aiNumMeshesPerPType[2], ((configRemoveMeshes & aiPrimitiveType_TRIANGLE) ? "X" : ""),
aiNumMeshesPerPType[3], ((configRemoveMeshes & aiPrimitiveType_POLYGON) ? "X" : "")); aiNumMeshesPerPType[3], ((configRemoveMeshes & aiPrimitiveType_POLYGON) ? "X" : ""));
DefaultLogger::get()->info(buffer); ASSIMP_LOG_INFO(buffer);
DefaultLogger::get()->debug("SortByPTypeProcess finished"); ASSIMP_LOG_DEBUG("SortByPTypeProcess finished");
} }
} }

6
code/SplitByBoneCountProcess.cpp
View File

@ -88,7 +88,7 @@ void SplitByBoneCountProcess::SetupProperties(const Importer* pImp)
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void SplitByBoneCountProcess::Execute( aiScene* pScene) void SplitByBoneCountProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("SplitByBoneCountProcess begin"); ASSIMP_LOG_DEBUG("SplitByBoneCountProcess begin");
// early out // early out
bool isNecessary = false; bool isNecessary = false;
@ -98,7 +98,7 @@ void SplitByBoneCountProcess::Execute( aiScene* pScene)
if( !isNecessary ) if( !isNecessary )
{ {
DefaultLogger::get()->debug( format() << "SplitByBoneCountProcess early-out: no meshes with more than " << mMaxBoneCount << " bones." ); ASSIMP_LOG_DEBUG( format() << "SplitByBoneCountProcess early-out: no meshes with more than " << mMaxBoneCount << " bones." );
return; return;
} }
@ -146,7 +146,7 @@ void SplitByBoneCountProcess::Execute( aiScene* pScene)
// recurse through all nodes and translate the node's mesh indices to fit the new mesh array // recurse through all nodes and translate the node's mesh indices to fit the new mesh array
UpdateNode( pScene->mRootNode); UpdateNode( pScene->mRootNode);
DefaultLogger::get()->debug( format() << "SplitByBoneCountProcess end: split " << mSubMeshIndices.size() << " meshes into " << meshes.size() << " submeshes." ); ASSIMP_LOG_DEBUG( format() << "SplitByBoneCountProcess end: split " << mSubMeshIndices.size() << " meshes into " << meshes.size() << " submeshes." );
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

19
code/SplitLargeMeshes.cpp
View File

@ -78,7 +78,7 @@ void SplitLargeMeshesProcess_Triangle::Execute( aiScene* pScene)
{ {
if (0xffffffff == this->LIMIT)return; if (0xffffffff == this->LIMIT)return;
DefaultLogger::get()->debug("SplitLargeMeshesProcess_Triangle begin"); ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Triangle begin");
std::vector<std::pair<aiMesh*, unsigned int> > avList; std::vector<std::pair<aiMesh*, unsigned int> > avList;
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
@ -96,10 +96,11 @@ void SplitLargeMeshesProcess_Triangle::Execute( aiScene* pScene)
// now we need to update all nodes // now we need to update all nodes
this->UpdateNode(pScene->mRootNode,avList); this->UpdateNode(pScene->mRootNode,avList);
DefaultLogger::get()->info("SplitLargeMeshesProcess_Triangle finished. Meshes have been split"); ASSIMP_LOG_INFO("SplitLargeMeshesProcess_Triangle finished. Meshes have been split");
}
else {
ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Triangle finished. There was nothing to do");
} }
else DefaultLogger::get()->debug("SplitLargeMeshesProcess_Triangle finished. There was nothing to do");
return;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
@ -154,7 +155,7 @@ void SplitLargeMeshesProcess_Triangle::SplitMesh(
{ {
if (pMesh->mNumFaces > SplitLargeMeshesProcess_Triangle::LIMIT) if (pMesh->mNumFaces > SplitLargeMeshesProcess_Triangle::LIMIT)
{ {
DefaultLogger::get()->info("Mesh exceeds the triangle limit. It will be split ..."); ASSIMP_LOG_INFO("Mesh exceeds the triangle limit. It will be split ...");
// we need to split this mesh into sub meshes // we need to split this mesh into sub meshes
// determine the size of a submesh // determine the size of a submesh
@ -378,7 +379,7 @@ void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene)
if (0xffffffff == this->LIMIT)return; if (0xffffffff == this->LIMIT)return;
DefaultLogger::get()->debug("SplitLargeMeshesProcess_Vertex begin"); ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Vertex begin");
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
this->SplitMesh(a, pScene->mMeshes[a],avList); this->SplitMesh(a, pScene->mMeshes[a],avList);
@ -394,10 +395,10 @@ void SplitLargeMeshesProcess_Vertex::Execute( aiScene* pScene)
// now we need to update all nodes // now we need to update all nodes
SplitLargeMeshesProcess_Triangle::UpdateNode(pScene->mRootNode,avList); SplitLargeMeshesProcess_Triangle::UpdateNode(pScene->mRootNode,avList);
DefaultLogger::get()->info("SplitLargeMeshesProcess_Vertex finished. Meshes have been split"); ASSIMP_LOG_INFO("SplitLargeMeshesProcess_Vertex finished. Meshes have been split");
} else {
ASSIMP_LOG_DEBUG("SplitLargeMeshesProcess_Vertex finished. There was nothing to do");
} }
else DefaultLogger::get()->debug("SplitLargeMeshesProcess_Vertex finished. There was nothing to do");
return;
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------

17
code/Subdivision.cpp
View File

@ -177,7 +177,7 @@ void CatmullClarkSubdivider::Subdivide (
aiMesh* i = smesh[s]; aiMesh* i = smesh[s];
// FIX - mPrimitiveTypes might not yet be initialized // FIX - mPrimitiveTypes might not yet be initialized
if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE|aiPrimitiveType_POINT))==i->mPrimitiveTypes) { if (i->mPrimitiveTypes && (i->mPrimitiveTypes & (aiPrimitiveType_LINE|aiPrimitiveType_POINT))==i->mPrimitiveTypes) {
DefaultLogger::get()->debug("Catmull-Clark Subdivider: Skipping pure line/point mesh"); ASSIMP_LOG_DEBUG("Catmull-Clark Subdivider: Skipping pure line/point mesh");
if (discard_input) { if (discard_input) {
out[s] = i; out[s] = i;
@ -198,12 +198,12 @@ void CatmullClarkSubdivider::Subdivide (
// checking any ranges. // checking any ranges.
ai_assert(inmeshes.size()==outmeshes.size()&&inmeshes.size()==maptbl.size()); ai_assert(inmeshes.size()==outmeshes.size()&&inmeshes.size()==maptbl.size());
if (inmeshes.empty()) { if (inmeshes.empty()) {
DefaultLogger::get()->warn("Catmull-Clark Subdivider: Pure point/line scene, I can't do anything"); ASSIMP_LOG_WARN("Catmull-Clark Subdivider: Pure point/line scene, I can't do anything");
return; return;
} }
InternSubdivide(&inmeshes.front(),inmeshes.size(),&outmeshes.front(),num); InternSubdivide(&inmeshes.front(),inmeshes.size(),&outmeshes.front(),num);
for (unsigned int i = 0; i < maptbl.size(); ++i) { for (unsigned int i = 0; i < maptbl.size(); ++i) {
ai_assert(outmeshes[i]); ai_assert(nullptr != outmeshes[i]);
out[maptbl[i]] = outmeshes[i]; out[maptbl[i]] = outmeshes[i];
} }
@ -342,11 +342,8 @@ void CatmullClarkSubdivider::InternSubdivide (
// Report the number of bad edges. bad edges are referenced by less than two // Report the number of bad edges. bad edges are referenced by less than two
// faces in the mesh. They occur at outer model boundaries in non-closed // faces in the mesh. They occur at outer model boundaries in non-closed
// shapes. // shapes.
char tmp[512]; ASSIMP_LOG_DEBUG_F("Catmull-Clark Subdivider: got ", bad_cnt, " bad edges touching only one face (totally ",
ai_snprintf(tmp, 512, "Catmull-Clark Subdivider: got %u bad edges touching only one face (totally %u edges). ", static_cast<unsigned int>(edges.size()), " edges). ");
bad_cnt,static_cast<unsigned int>(edges.size()));
DefaultLogger::get()->debug(tmp);
}} }}
// --------------------------------------------------------------------- // ---------------------------------------------------------------------
@ -404,7 +401,7 @@ void CatmullClarkSubdivider::InternSubdivide (
} }
ai_assert(haveit); ai_assert(haveit);
if (!haveit) { if (!haveit) {
DefaultLogger::get()->debug("Catmull-Clark Subdivider: Index not used"); ASSIMP_LOG_DEBUG("Catmull-Clark Subdivider: Index not used");
} }
break; break;
} }
@ -563,7 +560,7 @@ void CatmullClarkSubdivider::InternSubdivide (
// this invariant *must* hold if the vertex-to-face adjacency table is valid // this invariant *must* hold if the vertex-to-face adjacency table is valid
ai_assert(haveit); ai_assert(haveit);
if ( !haveit ) { if ( !haveit ) {
DefaultLogger::get()->warn( "OBJ: no name for material library specified." ); ASSIMP_LOG_WARN( "OBJ: no name for material library specified." );
} }
} }

2
code/TerragenLoader.cpp
View File

@ -192,7 +192,7 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
{ {
mode = reader.GetI1(); mode = reader.GetI1();
if (0 != mode) if (0 != mode)
DefaultLogger::get()->error("TER: Unsupported mapping mode, a flat terrain is returned"); ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned");
} }
// actual terrain data // actual terrain data
else if (!::strncmp(head,AI_TERR_CHUNK_ALTW,4)) else if (!::strncmp(head,AI_TERR_CHUNK_ALTW,4))

34
code/TextureTransform.cpp
View File

@ -105,12 +105,10 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
if (info.mRotation) if (info.mRotation)
{ {
float out = info.mRotation; float out = info.mRotation;
if ((rounded = (int)(info.mRotation / (float)AI_MATH_TWO_PI))) if ((rounded = static_cast<int>((info.mRotation / static_cast<float>(AI_MATH_TWO_PI)))))
{ {
out -= rounded*(float)AI_MATH_PI; out -= rounded * static_cast<float>(AI_MATH_PI);
ASSIMP_LOG_INFO_F("Texture coordinate rotation ", info.mRotation, " can be simplified to ", out);
ai_snprintf(szTemp, 512, "Texture coordinate rotation %f can be simplified to %f",info.mRotation,out);
DefaultLogger::get()->info(szTemp);
} }
// Next step - convert negative rotation angles to positives // Next step - convert negative rotation angles to positives
@ -150,7 +148,7 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
out = 1.f; out = 1.f;
} }
if (szTemp[0]) { if (szTemp[0]) {
DefaultLogger::get()->info(szTemp); ASSIMP_LOG_INFO(szTemp);
info.mTranslation.x = out; info.mTranslation.x = out;
} }
} }
@ -183,7 +181,7 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
out = 1.f; out = 1.f;
} }
if (szTemp[0]) { if (szTemp[0]) {
DefaultLogger::get()->info(szTemp); ASSIMP_LOG_INFO(szTemp);
info.mTranslation.y = out; info.mTranslation.y = out;
} }
} }
@ -221,7 +219,7 @@ inline const char* MappingModeToChar(aiTextureMapMode map)
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
void TextureTransformStep::Execute( aiScene* pScene) void TextureTransformStep::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("TransformUVCoordsProcess begin"); ASSIMP_LOG_DEBUG("TransformUVCoordsProcess begin");
/* We build a per-mesh list of texture transformations we'll need /* We build a per-mesh list of texture transformations we'll need
@ -331,7 +329,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
} }
if (mesh->mNumUVComponents[info.uvIndex] >= 3){ if (mesh->mNumUVComponents[info.uvIndex] >= 3){
DefaultLogger::get()->warn("UV transformations on 3D mapping channels are not supported"); ASSIMP_LOG_WARN("UV transformations on 3D mapping channels are not supported");
continue; continue;
} }
@ -416,7 +414,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
++it2; ++it2;
if ((*it2).lockedPos != AI_TT_UV_IDX_LOCK_NONE) { if ((*it2).lockedPos != AI_TT_UV_IDX_LOCK_NONE) {
DefaultLogger::get()->error("Channel mismatch, can't compute all transformations properly [design bug]"); ASSIMP_LOG_ERROR("Channel mismatch, can't compute all transformations properly [design bug]");
continue; continue;
} }
@ -449,10 +447,8 @@ void TextureTransformStep::Execute( aiScene* pScene)
if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) { if (size > AI_MAX_NUMBER_OF_TEXTURECOORDS) {
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
::ai_snprintf(buffer,1024,"%u UV channels required but just %u available", ASSIMP_LOG_ERROR_F(static_cast<unsigned int>(trafo.size()), " UV channels required but just ",
static_cast<unsigned int>(trafo.size()),AI_MAX_NUMBER_OF_TEXTURECOORDS); AI_MAX_NUMBER_OF_TEXTURECOORDS, " available");
DefaultLogger::get()->error(buffer);
} }
size = AI_MAX_NUMBER_OF_TEXTURECOORDS; size = AI_MAX_NUMBER_OF_TEXTURECOORDS;
} }
@ -487,7 +483,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
MappingModeToChar ((*it).mapU), MappingModeToChar ((*it).mapU),
MappingModeToChar ((*it).mapV)); MappingModeToChar ((*it).mapV));
DefaultLogger::get()->info(buffer); ASSIMP_LOG_INFO(buffer);
} }
// Check whether we need a new buffer here // Check whether we need a new buffer here
@ -560,12 +556,10 @@ void TextureTransformStep::Execute( aiScene* pScene)
if (!DefaultLogger::isNullLogger()) { if (!DefaultLogger::isNullLogger()) {
if (transformedChannels) { if (transformedChannels) {
::ai_snprintf(buffer,1024,"TransformUVCoordsProcess end: %u output channels (in: %u, modified: %u)", ASSIMP_LOG_INFO_F("TransformUVCoordsProcess end: ", outChannels, " output channels (in: ", inChannels, ", modified: ", transformedChannels,")");
outChannels,inChannels,transformedChannels); } else {
ASSIMP_LOG_DEBUG("TransformUVCoordsProcess finished");
DefaultLogger::get()->info(buffer);
} }
else DefaultLogger::get()->debug("TransformUVCoordsProcess finished");
} }
} }

11
code/TriangulateProcess.cpp
View File

@ -100,7 +100,7 @@ bool TriangulateProcess::IsActive( unsigned int pFlags) const
// Executes the post processing step on the given imported data. // Executes the post processing step on the given imported data.
void TriangulateProcess::Execute( aiScene* pScene) void TriangulateProcess::Execute( aiScene* pScene)
{ {
DefaultLogger::get()->debug("TriangulateProcess begin"); ASSIMP_LOG_DEBUG("TriangulateProcess begin");
bool bHas = false; bool bHas = false;
for( unsigned int a = 0; a < pScene->mNumMeshes; a++) for( unsigned int a = 0; a < pScene->mNumMeshes; a++)
@ -110,13 +110,12 @@ void TriangulateProcess::Execute( aiScene* pScene)
} }
} }
if ( bHas ) { if ( bHas ) {
DefaultLogger::get()->info( "TriangulateProcess finished. All polygons have been triangulated." ); ASSIMP_LOG_INFO( "TriangulateProcess finished. All polygons have been triangulated." );
} else { } else {
DefaultLogger::get()->debug( "TriangulateProcess finished. There was nothing to be done." ); ASSIMP_LOG_DEBUG( "TriangulateProcess finished. There was nothing to be done." );
} }
} }
// ------------------------------------------------------------------------------------------------ // ------------------------------------------------------------------------------------------------
// Triangulates the given mesh. // Triangulates the given mesh.
bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh) bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
@ -410,7 +409,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
// Instead we're continuing with the standard tri-fanning algorithm which we'd // Instead we're continuing with the standard tri-fanning algorithm which we'd
// use if we had only convex polygons. That's life. // use if we had only convex polygons. That's life.
DefaultLogger::get()->error("Failed to triangulate polygon (no ear found). Probably not a simple polygon?"); ASSIMP_LOG_ERROR("Failed to triangulate polygon (no ear found). Probably not a simple polygon?");
#ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS #ifdef AI_BUILD_TRIANGULATE_DEBUG_POLYS
fprintf(fout,"critical error here, no ear found! "); fprintf(fout,"critical error here, no ear found! ");
@ -488,7 +487,7 @@ bool TriangulateProcess::TriangulateMesh( aiMesh* pMesh)
// drop dumb 0-area triangles // drop dumb 0-area triangles
if (std::fabs(GetArea2D(temp_verts[i[0]],temp_verts[i[1]],temp_verts[i[2]])) < 1e-5f) { if (std::fabs(GetArea2D(temp_verts[i[0]],temp_verts[i[1]],temp_verts[i[2]])) < 1e-5f) {
DefaultLogger::get()->debug("Dropping triangle with area 0"); ASSIMP_LOG_DEBUG("Dropping triangle with area 0");
--curOut; --curOut;
delete[] f->mIndices; delete[] f->mIndices;

Some files were not shown because too many files have changed in this diff Show More