// ------------------------------------------------------------------------------------------------ // Imports a texture file. bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model, Q3BSP::Q3BSPZipArchive *archive, aiScene*, aiMaterial *pMatHelper, int textureId ) { if (nullptr == archive || nullptr == pMatHelper ) { return false; } if ( textureId < 0 || textureId >= static_cast<int>( model->m_Textures.size() ) ) { return false; } bool res = true; sQ3BSPTexture *pTexture = model->m_Textures[ textureId ]; if ( !pTexture ) { return false; } std::vector<std::string> supportedExtensions; supportedExtensions.push_back( ".jpg" ); supportedExtensions.push_back( ".png" ); supportedExtensions.push_back( ".tga" ); std::string textureName, ext; if ( expandFile( archive, pTexture->strName, supportedExtensions, textureName, ext ) ) { IOStream *pTextureStream = archive->Open( textureName.c_str() ); if ( pTextureStream ) { size_t texSize = pTextureStream->FileSize(); aiTexture *pTexture = new aiTexture; pTexture->mHeight = 0; pTexture->mWidth = static_cast<unsigned int>(texSize); unsigned char *pData = new unsigned char[ pTexture->mWidth ]; size_t readSize = pTextureStream->Read( pData, sizeof( unsigned char ), pTexture->mWidth ); (void)readSize; ai_assert( readSize == pTexture->mWidth ); pTexture->pcData = reinterpret_cast<aiTexel*>( pData ); pTexture->achFormatHint[ 0 ] = ext[ 1 ]; pTexture->achFormatHint[ 1 ] = ext[ 2 ]; pTexture->achFormatHint[ 2 ] = ext[ 3 ]; pTexture->achFormatHint[ 3 ] = '\0'; res = true; aiString name; name.data[ 0 ] = '*'; name.length = 1 + ASSIMP_itoa10( name.data + 1, static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(mTextures.size()) ); archive->Close( pTextureStream ); pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) ); mTextures.push_back( pTexture ); } else { // If it doesn't exist in the archive, it is probably just a reference to an external file. // We'll leave it up to the user to figure out which extension the file has. aiString name; strncpy( name.data, pTexture->strName, sizeof name.data ); name.length = strlen( name.data ); pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) ); } } return res; }
void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOSystem* pIOHandler ) { IOStream * stream = pIOHandler->Open(pFile,"rb"); if (!stream) return; stream->Seek( 44, aiOrigin_CUR ); // signature /*unsigned int versionMajor =*/ Read<unsigned int>(stream); /*unsigned int versionMinor =*/ Read<unsigned int>(stream); /*unsigned int versionRevision =*/ Read<unsigned int>(stream); /*unsigned int compileFlags =*/ Read<unsigned int>(stream); shortened = Read<uint16_t>(stream) > 0; compressed = Read<uint16_t>(stream) > 0; if (shortened) throw DeadlyImportError( "Shortened binaries are not supported!" ); stream->Seek( 256, aiOrigin_CUR ); // original filename stream->Seek( 128, aiOrigin_CUR ); // options stream->Seek( 64, aiOrigin_CUR ); // padding if (compressed) { uLongf uncompressedSize = Read<uint32_t>(stream); uLongf compressedSize = stream->FileSize() - stream->Tell(); unsigned char * compressedData = new unsigned char[ compressedSize ]; stream->Read( compressedData, 1, compressedSize ); unsigned char * uncompressedData = new unsigned char[ uncompressedSize ]; uncompress( uncompressedData, &uncompressedSize, compressedData, compressedSize ); MemoryIOStream io( uncompressedData, uncompressedSize ); ReadBinaryScene(&io,pScene); delete[] uncompressedData; delete[] compressedData; } else { ReadBinaryScene(stream,pScene); } pIOHandler->Close(stream); }
// ------------------------------------------------------------------------------------------------ bool Q3BSPFileParser::readData( const std::string &rMapName ) { if ( !m_pZipArchive->Exists( rMapName.c_str() ) ) return false; IOStream *pMapFile = m_pZipArchive->Open( rMapName.c_str() ); if ( NULL == pMapFile ) return false; const size_t size = pMapFile->FileSize(); m_Data.resize( size ); const size_t readSize = pMapFile->Read( &m_Data[0], sizeof( char ), size ); if ( readSize != size ) { m_Data.clear(); return false; } m_pZipArchive->Close( pMapFile ); return true; }
// ------------------------------------------------------------------------------------------------ // Reads the given file and returns its contents if successful. const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) { ASSIMP_BEGIN_EXCEPTION_REGION(); const std::string pFile(_pFile); // ---------------------------------------------------------------------- // Put a large try block around everything to catch all std::exception's // that might be thrown by STL containers or by new(). // ImportErrorException's are throw by ourselves and caught elsewhere. //----------------------------------------------------------------------- WriteLogOpening(pFile); #ifdef ASSIMP_CATCH_GLOBAL_EXCEPTIONS try #endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS { // Check whether this Importer instance has already loaded // a scene. In this case we need to delete the old one if (pimpl->mScene) { DefaultLogger::get()->debug("(Deleting previous scene)"); FreeScene(); } // First check if the file is accessable at all if( !pimpl->mIOHandler->Exists( pFile)) { pimpl->mErrorString = "Unable to open file \"" + pFile + "\"."; DefaultLogger::get()->error(pimpl->mErrorString); return NULL; } boost::scoped_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME,0)?new Profiler():NULL); if (profiler) { profiler->BeginRegion("total"); } // Find an worker class which can handle the file BaseImporter* imp = NULL; for( unsigned int a = 0; a < pimpl->mImporter.size(); a++) { if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, false)) { imp = pimpl->mImporter[a]; break; } } if (!imp) { // not so bad yet ... try format auto detection. const std::string::size_type s = pFile.find_last_of('.'); if (s != std::string::npos) { DefaultLogger::get()->info("File extension not known, trying signature-based detection"); for( unsigned int a = 0; a < pimpl->mImporter.size(); a++) { if( pimpl->mImporter[a]->CanRead( pFile, pimpl->mIOHandler, true)) { imp = pimpl->mImporter[a]; break; } } } // Put a proper error message if no suitable importer was found if( !imp) { pimpl->mErrorString = "No suitable reader found for the file format of file \"" + pFile + "\"."; DefaultLogger::get()->error(pimpl->mErrorString); return NULL; } } // Get file size for progress handler IOStream * fileIO = pimpl->mIOHandler->Open( pFile ); uint32_t fileSize = 0; if (fileIO) { fileSize = fileIO->FileSize(); pimpl->mIOHandler->Close( fileIO ); } // Dispatch the reading to the worker class for this format DefaultLogger::get()->info("Found a matching importer for this file format"); pimpl->mProgressHandler->UpdateFileRead( 0, fileSize ); if (profiler) { profiler->BeginRegion("import"); } pimpl->mScene = imp->ReadFile( this, pFile, pimpl->mIOHandler); pimpl->mProgressHandler->UpdateFileRead( fileSize, fileSize ); if (profiler) { profiler->EndRegion("import"); } // If successful, apply all active post processing steps to the imported data if( pimpl->mScene) { #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS // The ValidateDS process is an exception. It is executed first, even before ScenePreprocessor is called. if (pFlags & aiProcess_ValidateDataStructure) { ValidateDSProcess ds; ds.ExecuteOnScene (this); if (!pimpl->mScene) { return NULL; } } #endif // no validation // Preprocess the scene and prepare it for post-processing if (profiler) { profiler->BeginRegion("preprocess"); } ScenePreprocessor pre(pimpl->mScene); pre.ProcessScene(); if (profiler) { profiler->EndRegion("preprocess"); } // Ensure that the validation process won't be called twice ApplyPostProcessing(pFlags & (~aiProcess_ValidateDataStructure)); } // if failed, extract the error string else if( !pimpl->mScene) { pimpl->mErrorString = imp->GetErrorText(); } // clear any data allocated by post-process steps pimpl->mPPShared->Clean(); if (profiler) { profiler->EndRegion("total"); } } #ifdef ASSIMP_CATCH_GLOBAL_EXCEPTIONS catch (std::exception &e) { #if (defined _MSC_VER) && (defined _CPPRTTI) // if we have RTTI get the full name of the exception that occured pimpl->mErrorString = std::string(typeid( e ).name()) + ": " + e.what(); #else pimpl->mErrorString = std::string("std::exception: ") + e.what(); #endif DefaultLogger::get()->error(pimpl->mErrorString); delete pimpl->mScene; pimpl->mScene = NULL; } #endif // ! ASSIMP_CATCH_GLOBAL_EXCEPTIONS // either successful or failure - the pointer expresses it anyways ASSIMP_END_EXCEPTION_REGION(const aiScene*); return pimpl->mScene; }