1196 lines
41 KiB
C++
1196 lines
41 KiB
C++
/*
|
|
---------------------------------------------------------------------------
|
|
Open Asset Import Library (assimp)
|
|
---------------------------------------------------------------------------
|
|
|
|
Copyright (c) 2006-2017, assimp team
|
|
|
|
|
|
All rights reserved.
|
|
|
|
Redistribution and use of this software in source and binary forms,
|
|
with or without modification, are permitted provided that the following
|
|
conditions are met:
|
|
|
|
* Redistributions of source code must retain the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer.
|
|
|
|
* Redistributions in binary form must reproduce the above
|
|
copyright notice, this list of conditions and the
|
|
following disclaimer in the documentation and/or other
|
|
materials provided with the distribution.
|
|
|
|
* Neither the name of the assimp team, nor the names of its
|
|
contributors may be used to endorse or promote products
|
|
derived from this software without specific prior
|
|
written permission of the assimp team.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
---------------------------------------------------------------------------
|
|
*/
|
|
|
|
/** @file Importer.cpp
|
|
* @brief Implementation of the CPP-API class #Importer
|
|
*/
|
|
|
|
#include <assimp/version.h>
|
|
#include <assimp/config.h>
|
|
#include <assimp/importerdesc.h>
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
/* Uncomment this line to prevent Assimp from catching unknown exceptions.
|
|
*
|
|
* Note that any Exception except DeadlyImportError may lead to
|
|
* undefined behaviour -> loaders could remain in an unusable state and
|
|
* further imports with the same Importer instance could fail/crash/burn ...
|
|
*/
|
|
// ------------------------------------------------------------------------------------------------
|
|
#ifndef ASSIMP_BUILD_DEBUG
|
|
# define ASSIMP_CATCH_GLOBAL_EXCEPTIONS
|
|
#endif
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Internal headers
|
|
// ------------------------------------------------------------------------------------------------
|
|
#include "Importer.h"
|
|
#include "BaseImporter.h"
|
|
#include "BaseProcess.h"
|
|
|
|
#include "DefaultProgressHandler.h"
|
|
#include "GenericProperty.h"
|
|
#include "ProcessHelper.h"
|
|
#include "ScenePreprocessor.h"
|
|
#include "ScenePrivate.h"
|
|
#include "MemoryIOWrapper.h"
|
|
#include "Profiler.h"
|
|
#include "TinyFormatter.h"
|
|
#include "Exceptional.h"
|
|
#include "Profiler.h"
|
|
#include <set>
|
|
#include <memory>
|
|
#include <cctype>
|
|
|
|
#include <assimp/DefaultIOStream.h>
|
|
#include <assimp/DefaultIOSystem.h>
|
|
|
|
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
# include "ValidateDataStructure.h"
|
|
#endif
|
|
|
|
using namespace Assimp::Profiling;
|
|
using namespace Assimp::Formatter;
|
|
|
|
namespace Assimp {
|
|
// ImporterRegistry.cpp
|
|
void GetImporterInstanceList(std::vector< BaseImporter* >& out);
|
|
void DeleteImporterInstanceList(std::vector< BaseImporter* >& out);
|
|
|
|
// PostStepRegistry.cpp
|
|
void GetPostProcessingStepInstanceList(std::vector< BaseProcess* >& out);
|
|
}
|
|
|
|
using namespace Assimp;
|
|
using namespace Assimp::Intern;
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Intern::AllocateFromAssimpHeap serves as abstract base class. It overrides
|
|
// new and delete (and their array counterparts) of public API classes (e.g. Logger) to
|
|
// utilize our DLL heap.
|
|
// See http://www.gotw.ca/publications/mill15.htm
|
|
// ------------------------------------------------------------------------------------------------
|
|
void* AllocateFromAssimpHeap::operator new ( size_t num_bytes) {
|
|
return ::operator new(num_bytes);
|
|
}
|
|
|
|
void* AllocateFromAssimpHeap::operator new ( size_t num_bytes, const std::nothrow_t& ) throw() {
|
|
try {
|
|
return AllocateFromAssimpHeap::operator new( num_bytes );
|
|
}
|
|
catch( ... ) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void AllocateFromAssimpHeap::operator delete ( void* data) {
|
|
return ::operator delete(data);
|
|
}
|
|
|
|
void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes) {
|
|
return ::operator new[](num_bytes);
|
|
}
|
|
|
|
void* AllocateFromAssimpHeap::operator new[] ( size_t num_bytes, const std::nothrow_t& ) throw() {
|
|
try {
|
|
return AllocateFromAssimpHeap::operator new[]( num_bytes );
|
|
}
|
|
catch( ... ) {
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
void AllocateFromAssimpHeap::operator delete[] ( void* data) {
|
|
return ::operator delete[](data);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Importer constructor.
|
|
Importer::Importer()
|
|
: pimpl( NULL ) {
|
|
// allocate the pimpl first
|
|
pimpl = new ImporterPimpl();
|
|
|
|
pimpl->mScene = NULL;
|
|
pimpl->mErrorString = "";
|
|
|
|
// Allocate a default IO handler
|
|
pimpl->mIOHandler = new DefaultIOSystem;
|
|
pimpl->mIsDefaultHandler = true;
|
|
pimpl->bExtraVerbose = false; // disable extra verbose mode by default
|
|
|
|
pimpl->mProgressHandler = new DefaultProgressHandler();
|
|
pimpl->mIsDefaultProgressHandler = true;
|
|
|
|
GetImporterInstanceList(pimpl->mImporter);
|
|
GetPostProcessingStepInstanceList(pimpl->mPostProcessingSteps);
|
|
|
|
// Allocate a SharedPostProcessInfo object and store pointers to it in all post-process steps in the list.
|
|
pimpl->mPPShared = new SharedPostProcessInfo();
|
|
for (std::vector<BaseProcess*>::iterator it = pimpl->mPostProcessingSteps.begin();
|
|
it != pimpl->mPostProcessingSteps.end();
|
|
++it) {
|
|
|
|
(*it)->SetSharedData(pimpl->mPPShared);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Destructor of Importer
|
|
Importer::~Importer()
|
|
{
|
|
// Delete all import plugins
|
|
DeleteImporterInstanceList(pimpl->mImporter);
|
|
|
|
// Delete all post-processing plug-ins
|
|
for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)
|
|
delete pimpl->mPostProcessingSteps[a];
|
|
|
|
// Delete the assigned IO and progress handler
|
|
delete pimpl->mIOHandler;
|
|
delete pimpl->mProgressHandler;
|
|
|
|
// Kill imported scene. Destructors should do that recursivly
|
|
delete pimpl->mScene;
|
|
|
|
// Delete shared post-processing data
|
|
delete pimpl->mPPShared;
|
|
|
|
// and finally the pimpl itself
|
|
delete pimpl;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Copy constructor - copies the config of another Importer, not the scene
|
|
Importer::Importer(const Importer &other)
|
|
: pimpl(NULL) {
|
|
new(this) Importer();
|
|
|
|
pimpl->mIntProperties = other.pimpl->mIntProperties;
|
|
pimpl->mFloatProperties = other.pimpl->mFloatProperties;
|
|
pimpl->mStringProperties = other.pimpl->mStringProperties;
|
|
pimpl->mMatrixProperties = other.pimpl->mMatrixProperties;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Register a custom post-processing step
|
|
aiReturn Importer::RegisterPPStep(BaseProcess* pImp)
|
|
{
|
|
ai_assert(NULL != pImp);
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
|
|
pimpl->mPostProcessingSteps.push_back(pImp);
|
|
DefaultLogger::get()->info("Registering custom post-processing step");
|
|
|
|
ASSIMP_END_EXCEPTION_REGION(aiReturn);
|
|
return AI_SUCCESS;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Register a custom loader plugin
|
|
aiReturn Importer::RegisterLoader(BaseImporter* pImp)
|
|
{
|
|
ai_assert(NULL != pImp);
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
|
|
// --------------------------------------------------------------------
|
|
// Check whether we would have two loaders for the same file extension
|
|
// This is absolutely OK, but we should warn the developer of the new
|
|
// loader that his code will probably never be called if the first
|
|
// loader is a bit too lazy in his file checking.
|
|
// --------------------------------------------------------------------
|
|
std::set<std::string> st;
|
|
std::string baked;
|
|
pImp->GetExtensionList(st);
|
|
|
|
for(std::set<std::string>::const_iterator it = st.begin(); it != st.end(); ++it) {
|
|
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
if (IsExtensionSupported(*it)) {
|
|
DefaultLogger::get()->warn("The file extension " + *it + " is already in use");
|
|
}
|
|
#endif
|
|
baked += *it;
|
|
}
|
|
|
|
// add the loader
|
|
pimpl->mImporter.push_back(pImp);
|
|
DefaultLogger::get()->info("Registering custom importer for these file extensions: " + baked);
|
|
ASSIMP_END_EXCEPTION_REGION(aiReturn);
|
|
return AI_SUCCESS;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Unregister a custom loader plugin
|
|
aiReturn Importer::UnregisterLoader(BaseImporter* pImp)
|
|
{
|
|
if(!pImp) {
|
|
// unregistering a NULL importer is no problem for us ... really!
|
|
return AI_SUCCESS;
|
|
}
|
|
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
std::vector<BaseImporter*>::iterator it = std::find(pimpl->mImporter.begin(),
|
|
pimpl->mImporter.end(),pImp);
|
|
|
|
if (it != pimpl->mImporter.end()) {
|
|
pimpl->mImporter.erase(it);
|
|
DefaultLogger::get()->info("Unregistering custom importer: ");
|
|
return AI_SUCCESS;
|
|
}
|
|
DefaultLogger::get()->warn("Unable to remove custom importer: I can't find you ...");
|
|
ASSIMP_END_EXCEPTION_REGION(aiReturn);
|
|
return AI_FAILURE;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Unregister a custom loader plugin
|
|
aiReturn Importer::UnregisterPPStep(BaseProcess* pImp)
|
|
{
|
|
if(!pImp) {
|
|
// unregistering a NULL ppstep is no problem for us ... really!
|
|
return AI_SUCCESS;
|
|
}
|
|
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
std::vector<BaseProcess*>::iterator it = std::find(pimpl->mPostProcessingSteps.begin(),
|
|
pimpl->mPostProcessingSteps.end(),pImp);
|
|
|
|
if (it != pimpl->mPostProcessingSteps.end()) {
|
|
pimpl->mPostProcessingSteps.erase(it);
|
|
DefaultLogger::get()->info("Unregistering custom post-processing step");
|
|
return AI_SUCCESS;
|
|
}
|
|
DefaultLogger::get()->warn("Unable to remove custom post-processing step: I can't find you ..");
|
|
ASSIMP_END_EXCEPTION_REGION(aiReturn);
|
|
return AI_FAILURE;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Supplies a custom IO handler to the importer to open and access files.
|
|
void Importer::SetIOHandler( IOSystem* pIOHandler)
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
// If the new handler is zero, allocate a default IO implementation.
|
|
if (!pIOHandler)
|
|
{
|
|
// Release pointer in the possession of the caller
|
|
pimpl->mIOHandler = new DefaultIOSystem();
|
|
pimpl->mIsDefaultHandler = true;
|
|
}
|
|
// Otherwise register the custom handler
|
|
else if (pimpl->mIOHandler != pIOHandler)
|
|
{
|
|
delete pimpl->mIOHandler;
|
|
pimpl->mIOHandler = pIOHandler;
|
|
pimpl->mIsDefaultHandler = false;
|
|
}
|
|
ASSIMP_END_EXCEPTION_REGION(void);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get the currently set IO handler
|
|
IOSystem* Importer::GetIOHandler() const
|
|
{
|
|
return pimpl->mIOHandler;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Check whether a custom IO handler is currently set
|
|
bool Importer::IsDefaultIOHandler() const
|
|
{
|
|
return pimpl->mIsDefaultHandler;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Supplies a custom progress handler to get regular callbacks during importing
|
|
void Importer::SetProgressHandler ( ProgressHandler* pHandler )
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
// If the new handler is zero, allocate a default implementation.
|
|
if (!pHandler)
|
|
{
|
|
// Release pointer in the possession of the caller
|
|
pimpl->mProgressHandler = new DefaultProgressHandler();
|
|
pimpl->mIsDefaultProgressHandler = true;
|
|
}
|
|
// Otherwise register the custom handler
|
|
else if (pimpl->mProgressHandler != pHandler)
|
|
{
|
|
delete pimpl->mProgressHandler;
|
|
pimpl->mProgressHandler = pHandler;
|
|
pimpl->mIsDefaultProgressHandler = false;
|
|
}
|
|
ASSIMP_END_EXCEPTION_REGION(void);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get the currently set progress handler
|
|
ProgressHandler* Importer::GetProgressHandler() const
|
|
{
|
|
return pimpl->mProgressHandler;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Check whether a custom progress handler is currently set
|
|
bool Importer::IsDefaultProgressHandler() const
|
|
{
|
|
return pimpl->mIsDefaultProgressHandler;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Validate post process step flags
|
|
bool _ValidateFlags(unsigned int pFlags)
|
|
{
|
|
if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals) {
|
|
DefaultLogger::get()->error("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible");
|
|
return false;
|
|
}
|
|
if (pFlags & aiProcess_OptimizeGraph && pFlags & aiProcess_PreTransformVertices) {
|
|
DefaultLogger::get()->error("#aiProcess_OptimizeGraph and #aiProcess_PreTransformVertices are incompatible");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Free the current scene
|
|
void Importer::FreeScene( )
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
delete pimpl->mScene;
|
|
pimpl->mScene = NULL;
|
|
|
|
pimpl->mErrorString = "";
|
|
ASSIMP_END_EXCEPTION_REGION(void);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get the current error string, if any
|
|
const char* Importer::GetErrorString() const
|
|
{
|
|
/* Must remain valid as long as ReadFile() or FreeFile() are not called */
|
|
return pimpl->mErrorString.c_str();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Enable extra-verbose mode
|
|
void Importer::SetExtraVerbose(bool bDo)
|
|
{
|
|
pimpl->bExtraVerbose = bDo;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get the current scene
|
|
const aiScene* Importer::GetScene() const
|
|
{
|
|
return pimpl->mScene;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Orphan the current scene and return it.
|
|
aiScene* Importer::GetOrphanedScene()
|
|
{
|
|
aiScene* s = pimpl->mScene;
|
|
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
pimpl->mScene = NULL;
|
|
|
|
pimpl->mErrorString = ""; /* reset error string */
|
|
ASSIMP_END_EXCEPTION_REGION(aiScene*);
|
|
return s;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Validate post-processing flags
|
|
bool Importer::ValidateFlags(unsigned int pFlags) const
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
// run basic checks for mutually exclusive flags
|
|
if(!_ValidateFlags(pFlags)) {
|
|
return false;
|
|
}
|
|
|
|
// ValidateDS does not anymore occur in the pp list, it plays an awesome extra role ...
|
|
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
if (pFlags & aiProcess_ValidateDataStructure) {
|
|
return false;
|
|
}
|
|
#endif
|
|
pFlags &= ~aiProcess_ValidateDataStructure;
|
|
|
|
// Now iterate through all bits which are set in the flags and check whether we find at least
|
|
// one pp plugin which handles it.
|
|
for (unsigned int mask = 1; mask < (1u << (sizeof(unsigned int)*8-1));mask <<= 1) {
|
|
|
|
if (pFlags & mask) {
|
|
|
|
bool have = false;
|
|
for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
|
|
if (pimpl->mPostProcessingSteps[a]-> IsActive(mask) ) {
|
|
|
|
have = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!have) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
ASSIMP_END_EXCEPTION_REGION(bool);
|
|
return true;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
const aiScene* Importer::ReadFileFromMemory( const void* pBuffer,
|
|
size_t pLength,
|
|
unsigned int pFlags,
|
|
const char* pHint /*= ""*/)
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
if (!pHint) {
|
|
pHint = "";
|
|
}
|
|
|
|
if (!pBuffer || !pLength || strlen(pHint) > MaxLenHint ) {
|
|
pimpl->mErrorString = "Invalid parameters passed to ReadFileFromMemory()";
|
|
return NULL;
|
|
}
|
|
|
|
// prevent deletion of the previous IOHandler
|
|
IOSystem* io = pimpl->mIOHandler;
|
|
pimpl->mIOHandler = NULL;
|
|
|
|
SetIOHandler(new MemoryIOSystem((const uint8_t*)pBuffer,pLength));
|
|
|
|
// read the file and recover the previous IOSystem
|
|
static const size_t BufferSize(Importer::MaxLenHint + 28);
|
|
char fbuff[ BufferSize ];
|
|
ai_snprintf(fbuff, BufferSize, "%s.%s",AI_MEMORYIO_MAGIC_FILENAME,pHint);
|
|
|
|
ReadFile(fbuff,pFlags);
|
|
SetIOHandler(io);
|
|
|
|
ASSIMP_END_EXCEPTION_REGION(const aiScene*);
|
|
return pimpl->mScene;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
void WriteLogOpening(const std::string& file)
|
|
{
|
|
Logger* l = DefaultLogger::get();
|
|
if (!l) {
|
|
return;
|
|
}
|
|
l->info("Load " + file);
|
|
|
|
// print a full version dump. This is nice because we don't
|
|
// need to ask the authors of incoming bug reports for
|
|
// the library version they're using - a log dump is
|
|
// sufficient.
|
|
const unsigned int flags = aiGetCompileFlags();
|
|
l->debug(format()
|
|
<< "Assimp "
|
|
<< aiGetVersionMajor()
|
|
<< "."
|
|
<< aiGetVersionMinor()
|
|
<< "."
|
|
<< aiGetVersionRevision()
|
|
|
|
<< " "
|
|
#if defined(ASSIMP_BUILD_ARCHITECTURE)
|
|
<< ASSIMP_BUILD_ARCHITECTURE
|
|
#elif defined(_M_IX86) || defined(__x86_32__) || defined(__i386__)
|
|
<< "x86"
|
|
#elif defined(_M_X64) || defined(__x86_64__)
|
|
<< "amd64"
|
|
#elif defined(_M_IA64) || defined(__ia64__)
|
|
<< "itanium"
|
|
#elif defined(__ppc__) || defined(__powerpc__)
|
|
<< "ppc32"
|
|
#elif defined(__powerpc64__)
|
|
<< "ppc64"
|
|
#elif defined(__arm__)
|
|
<< "arm"
|
|
#else
|
|
<< "<unknown architecture>"
|
|
#endif
|
|
|
|
<< " "
|
|
#if defined(ASSIMP_BUILD_COMPILER)
|
|
<< ASSIMP_BUILD_COMPILER
|
|
#elif defined(_MSC_VER)
|
|
<< "msvc"
|
|
#elif defined(__GNUC__)
|
|
<< "gcc"
|
|
#else
|
|
<< "<unknown compiler>"
|
|
#endif
|
|
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
<< " debug"
|
|
#endif
|
|
|
|
<< (flags & ASSIMP_CFLAGS_NOBOOST ? " noboost" : "")
|
|
<< (flags & ASSIMP_CFLAGS_SHARED ? " shared" : "")
|
|
<< (flags & ASSIMP_CFLAGS_SINGLETHREADED ? " singlethreaded" : "")
|
|
);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// 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 accessible at all
|
|
if( !pimpl->mIOHandler->Exists( pFile)) {
|
|
|
|
pimpl->mErrorString = "Unable to open file \"" + pFile + "\".";
|
|
DefaultLogger::get()->error(pimpl->mErrorString);
|
|
return NULL;
|
|
}
|
|
|
|
std::unique_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 = static_cast<uint32_t>(fileIO->FileSize());
|
|
pimpl->mIOHandler->Close( fileIO );
|
|
}
|
|
|
|
// Dispatch the reading to the worker class for this format
|
|
const aiImporterDesc *desc( imp->GetInfo() );
|
|
std::string ext( "unknown" );
|
|
if ( NULL != desc ) {
|
|
ext = desc->mName;
|
|
}
|
|
DefaultLogger::get()->info("Found a matching importer for this file format: " + ext + "." );
|
|
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 occurred
|
|
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;
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Apply post-processing to the currently bound scene
|
|
const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
// Return immediately if no scene is active
|
|
if (!pimpl->mScene) {
|
|
return NULL;
|
|
}
|
|
|
|
// If no flags are given, return the current scene with no further action
|
|
if (!pFlags) {
|
|
return pimpl->mScene;
|
|
}
|
|
|
|
// In debug builds: run basic flag validation
|
|
ai_assert(_ValidateFlags(pFlags));
|
|
DefaultLogger::get()->info("Entering post processing pipeline");
|
|
|
|
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
// The ValidateDS process plays an exceptional role. It isn't contained in the global
|
|
// list of post-processing steps, so we need to call it manually.
|
|
if (pFlags & aiProcess_ValidateDataStructure)
|
|
{
|
|
ValidateDSProcess ds;
|
|
ds.ExecuteOnScene (this);
|
|
if (!pimpl->mScene) {
|
|
return NULL;
|
|
}
|
|
}
|
|
#endif // no validation
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
if (pimpl->bExtraVerbose)
|
|
{
|
|
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
DefaultLogger::get()->error("Verbose Import is not available due to build settings");
|
|
#endif // no validation
|
|
pFlags |= aiProcess_ValidateDataStructure;
|
|
}
|
|
#else
|
|
if (pimpl->bExtraVerbose) {
|
|
DefaultLogger::get()->warn("Not a debug build, ignoring extra verbose setting");
|
|
}
|
|
#endif // ! DEBUG
|
|
|
|
std::unique_ptr<Profiler> profiler(GetPropertyInteger(AI_CONFIG_GLOB_MEASURE_TIME,0)?new Profiler():NULL);
|
|
for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
|
|
|
|
BaseProcess* process = pimpl->mPostProcessingSteps[a];
|
|
pimpl->mProgressHandler->UpdatePostProcess(static_cast<int>(a), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
|
|
if( process->IsActive( pFlags)) {
|
|
|
|
if (profiler) {
|
|
profiler->BeginRegion("postprocess");
|
|
}
|
|
|
|
process->ExecuteOnScene ( this );
|
|
|
|
if (profiler) {
|
|
profiler->EndRegion("postprocess");
|
|
}
|
|
}
|
|
if( !pimpl->mScene) {
|
|
break;
|
|
}
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
|
|
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
continue;
|
|
#endif // no validation
|
|
|
|
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
|
|
if (pimpl->bExtraVerbose) {
|
|
DefaultLogger::get()->debug("Verbose Import: revalidating data structures");
|
|
|
|
ValidateDSProcess ds;
|
|
ds.ExecuteOnScene (this);
|
|
if( !pimpl->mScene) {
|
|
DefaultLogger::get()->error("Verbose Import: failed to revalidate data structures");
|
|
break;
|
|
}
|
|
}
|
|
#endif // ! DEBUG
|
|
}
|
|
pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
|
|
|
|
// update private scene flags
|
|
if( pimpl->mScene )
|
|
ScenePriv(pimpl->mScene)->mPPStepsApplied |= pFlags;
|
|
|
|
// clear any data allocated by post-process steps
|
|
pimpl->mPPShared->Clean();
|
|
DefaultLogger::get()->info("Leaving post processing pipeline");
|
|
|
|
ASSIMP_END_EXCEPTION_REGION(const aiScene*);
|
|
return pimpl->mScene;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
const aiScene* Importer::ApplyCustomizedPostProcessing( BaseProcess *rootProcess, bool requestValidation ) {
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
|
|
// Return immediately if no scene is active
|
|
if ( NULL == pimpl->mScene ) {
|
|
return NULL;
|
|
}
|
|
|
|
// If no flags are given, return the current scene with no further action
|
|
if ( NULL == rootProcess ) {
|
|
return pimpl->mScene;
|
|
}
|
|
|
|
// In debug builds: run basic flag validation
|
|
DefaultLogger::get()->info( "Entering customized post processing pipeline" );
|
|
|
|
#ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
// The ValidateDS process plays an exceptional role. It isn't contained in the global
|
|
// list of post-processing steps, so we need to call it manually.
|
|
if ( requestValidation )
|
|
{
|
|
ValidateDSProcess ds;
|
|
ds.ExecuteOnScene( this );
|
|
if ( !pimpl->mScene ) {
|
|
return NULL;
|
|
}
|
|
}
|
|
#endif // no validation
|
|
#ifdef ASSIMP_BUILD_DEBUG
|
|
if ( pimpl->bExtraVerbose )
|
|
{
|
|
#ifdef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
|
|
DefaultLogger::get()->error( "Verbose Import is not available due to build settings" );
|
|
#endif // no validation
|
|
}
|
|
#else
|
|
if ( pimpl->bExtraVerbose ) {
|
|
DefaultLogger::get()->warn( "Not a debug build, ignoring extra verbose setting" );
|
|
}
|
|
#endif // ! DEBUG
|
|
|
|
std::unique_ptr<Profiler> profiler( GetPropertyInteger( AI_CONFIG_GLOB_MEASURE_TIME, 0 ) ? new Profiler() : NULL );
|
|
|
|
if ( profiler ) {
|
|
profiler->BeginRegion( "postprocess" );
|
|
}
|
|
|
|
rootProcess->ExecuteOnScene( this );
|
|
|
|
if ( profiler ) {
|
|
profiler->EndRegion( "postprocess" );
|
|
}
|
|
|
|
// If the extra verbose mode is active, execute the ValidateDataStructureStep again - after each step
|
|
if ( pimpl->bExtraVerbose || requestValidation ) {
|
|
DefaultLogger::get()->debug( "Verbose Import: revalidating data structures" );
|
|
|
|
ValidateDSProcess ds;
|
|
ds.ExecuteOnScene( this );
|
|
if ( !pimpl->mScene ) {
|
|
DefaultLogger::get()->error( "Verbose Import: failed to revalidate data structures" );
|
|
}
|
|
}
|
|
|
|
// clear any data allocated by post-process steps
|
|
pimpl->mPPShared->Clean();
|
|
DefaultLogger::get()->info( "Leaving customized post processing pipeline" );
|
|
|
|
ASSIMP_END_EXCEPTION_REGION( const aiScene* );
|
|
|
|
return pimpl->mScene;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Helper function to check whether an extension is supported by ASSIMP
|
|
bool Importer::IsExtensionSupported(const char* szExtension) const
|
|
{
|
|
return NULL != GetImporter(szExtension);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
size_t Importer::GetImporterCount() const
|
|
{
|
|
return pimpl->mImporter.size();
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
const aiImporterDesc* Importer::GetImporterInfo(size_t index) const
|
|
{
|
|
if (index >= pimpl->mImporter.size()) {
|
|
return NULL;
|
|
}
|
|
return pimpl->mImporter[index]->GetInfo();
|
|
}
|
|
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
BaseImporter* Importer::GetImporter (size_t index) const
|
|
{
|
|
if (index >= pimpl->mImporter.size()) {
|
|
return NULL;
|
|
}
|
|
return pimpl->mImporter[index];
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Find a loader plugin for a given file extension
|
|
BaseImporter* Importer::GetImporter (const char* szExtension) const
|
|
{
|
|
return GetImporter(GetImporterIndex(szExtension));
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Find a loader plugin for a given file extension
|
|
size_t Importer::GetImporterIndex (const char* szExtension) const
|
|
{
|
|
ai_assert(szExtension);
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
|
|
// skip over wildcard and dot characters at string head --
|
|
for(;*szExtension == '*' || *szExtension == '.'; ++szExtension);
|
|
|
|
std::string ext(szExtension);
|
|
if (ext.empty()) {
|
|
return static_cast<size_t>(-1);
|
|
}
|
|
std::transform(ext.begin(),ext.end(), ext.begin(), tolower);
|
|
|
|
std::set<std::string> str;
|
|
for (std::vector<BaseImporter*>::const_iterator i = pimpl->mImporter.begin();i != pimpl->mImporter.end();++i) {
|
|
str.clear();
|
|
|
|
(*i)->GetExtensionList(str);
|
|
for (std::set<std::string>::const_iterator it = str.begin(); it != str.end(); ++it) {
|
|
if (ext == *it) {
|
|
return std::distance(static_cast< std::vector<BaseImporter*>::const_iterator >(pimpl->mImporter.begin()), i);
|
|
}
|
|
}
|
|
}
|
|
ASSIMP_END_EXCEPTION_REGION(size_t);
|
|
return static_cast<size_t>(-1);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Helper function to build a list of all file extensions supported by ASSIMP
|
|
void Importer::GetExtensionList(aiString& szOut) const
|
|
{
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
std::set<std::string> str;
|
|
for (std::vector<BaseImporter*>::const_iterator i = pimpl->mImporter.begin();i != pimpl->mImporter.end();++i) {
|
|
(*i)->GetExtensionList(str);
|
|
}
|
|
|
|
for (std::set<std::string>::const_iterator it = str.begin();; ) {
|
|
szOut.Append("*.");
|
|
szOut.Append((*it).c_str());
|
|
|
|
if (++it == str.end()) {
|
|
break;
|
|
}
|
|
szOut.Append(";");
|
|
}
|
|
ASSIMP_END_EXCEPTION_REGION(void);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Set a configuration property
|
|
bool Importer::SetPropertyInteger(const char* szName, int iValue)
|
|
{
|
|
bool existing;
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
existing = SetGenericProperty<int>(pimpl->mIntProperties, szName,iValue);
|
|
ASSIMP_END_EXCEPTION_REGION(bool);
|
|
return existing;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Set a configuration property
|
|
bool Importer::SetPropertyFloat(const char* szName, ai_real iValue)
|
|
{
|
|
bool exising;
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
exising = SetGenericProperty<ai_real>(pimpl->mFloatProperties, szName,iValue);
|
|
ASSIMP_END_EXCEPTION_REGION(bool);
|
|
return exising;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Set a configuration property
|
|
bool Importer::SetPropertyString(const char* szName, const std::string& value)
|
|
{
|
|
bool exising;
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
exising = SetGenericProperty<std::string>(pimpl->mStringProperties, szName,value);
|
|
ASSIMP_END_EXCEPTION_REGION(bool);
|
|
return exising;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Set a configuration property
|
|
bool Importer::SetPropertyMatrix(const char* szName, const aiMatrix4x4& value)
|
|
{
|
|
bool exising;
|
|
ASSIMP_BEGIN_EXCEPTION_REGION();
|
|
exising = SetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties, szName,value);
|
|
ASSIMP_END_EXCEPTION_REGION(bool);
|
|
return exising;
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get a configuration property
|
|
int Importer::GetPropertyInteger(const char* szName,
|
|
int iErrorReturn /*= 0xffffffff*/) const
|
|
{
|
|
return GetGenericProperty<int>(pimpl->mIntProperties,szName,iErrorReturn);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get a configuration property
|
|
ai_real Importer::GetPropertyFloat(const char* szName,
|
|
ai_real iErrorReturn /*= 10e10*/) const
|
|
{
|
|
return GetGenericProperty<ai_real>(pimpl->mFloatProperties,szName,iErrorReturn);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get a configuration property
|
|
const std::string Importer::GetPropertyString(const char* szName,
|
|
const std::string& iErrorReturn /*= ""*/) const
|
|
{
|
|
return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get a configuration property
|
|
const aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName,
|
|
const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const
|
|
{
|
|
return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get the memory requirements of a single node
|
|
inline void AddNodeWeight(unsigned int& iScene,const aiNode* pcNode)
|
|
{
|
|
iScene += sizeof(aiNode);
|
|
iScene += sizeof(unsigned int) * pcNode->mNumMeshes;
|
|
iScene += sizeof(void*) * pcNode->mNumChildren;
|
|
|
|
for (unsigned int i = 0; i < pcNode->mNumChildren;++i) {
|
|
AddNodeWeight(iScene,pcNode->mChildren[i]);
|
|
}
|
|
}
|
|
|
|
// ------------------------------------------------------------------------------------------------
|
|
// Get the memory requirements of the scene
|
|
void Importer::GetMemoryRequirements(aiMemoryInfo& in) const
|
|
{
|
|
in = aiMemoryInfo();
|
|
aiScene* mScene = pimpl->mScene;
|
|
|
|
// return if we have no scene loaded
|
|
if (!pimpl->mScene)
|
|
return;
|
|
|
|
|
|
in.total = sizeof(aiScene);
|
|
|
|
// add all meshes
|
|
for (unsigned int i = 0; i < mScene->mNumMeshes;++i)
|
|
{
|
|
in.meshes += sizeof(aiMesh);
|
|
if (mScene->mMeshes[i]->HasPositions()) {
|
|
in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
|
|
}
|
|
|
|
if (mScene->mMeshes[i]->HasNormals()) {
|
|
in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
|
|
}
|
|
|
|
if (mScene->mMeshes[i]->HasTangentsAndBitangents()) {
|
|
in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices * 2;
|
|
}
|
|
|
|
for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS;++a) {
|
|
if (mScene->mMeshes[i]->HasVertexColors(a)) {
|
|
in.meshes += sizeof(aiColor4D) * mScene->mMeshes[i]->mNumVertices;
|
|
}
|
|
else break;
|
|
}
|
|
for (unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS;++a) {
|
|
if (mScene->mMeshes[i]->HasTextureCoords(a)) {
|
|
in.meshes += sizeof(aiVector3D) * mScene->mMeshes[i]->mNumVertices;
|
|
}
|
|
else break;
|
|
}
|
|
if (mScene->mMeshes[i]->HasBones()) {
|
|
in.meshes += sizeof(void*) * mScene->mMeshes[i]->mNumBones;
|
|
for (unsigned int p = 0; p < mScene->mMeshes[i]->mNumBones;++p) {
|
|
in.meshes += sizeof(aiBone);
|
|
in.meshes += mScene->mMeshes[i]->mBones[p]->mNumWeights * sizeof(aiVertexWeight);
|
|
}
|
|
}
|
|
in.meshes += (sizeof(aiFace) + 3 * sizeof(unsigned int))*mScene->mMeshes[i]->mNumFaces;
|
|
}
|
|
in.total += in.meshes;
|
|
|
|
// add all embedded textures
|
|
for (unsigned int i = 0; i < mScene->mNumTextures;++i) {
|
|
const aiTexture* pc = mScene->mTextures[i];
|
|
in.textures += sizeof(aiTexture);
|
|
if (pc->mHeight) {
|
|
in.textures += 4 * pc->mHeight * pc->mWidth;
|
|
}
|
|
else in.textures += pc->mWidth;
|
|
}
|
|
in.total += in.textures;
|
|
|
|
// add all animations
|
|
for (unsigned int i = 0; i < mScene->mNumAnimations;++i) {
|
|
const aiAnimation* pc = mScene->mAnimations[i];
|
|
in.animations += sizeof(aiAnimation);
|
|
|
|
// add all bone anims
|
|
for (unsigned int a = 0; a < pc->mNumChannels; ++a) {
|
|
const aiNodeAnim* pc2 = pc->mChannels[i];
|
|
in.animations += sizeof(aiNodeAnim);
|
|
in.animations += pc2->mNumPositionKeys * sizeof(aiVectorKey);
|
|
in.animations += pc2->mNumScalingKeys * sizeof(aiVectorKey);
|
|
in.animations += pc2->mNumRotationKeys * sizeof(aiQuatKey);
|
|
}
|
|
}
|
|
in.total += in.animations;
|
|
|
|
// add all cameras and all lights
|
|
in.total += in.cameras = sizeof(aiCamera) * mScene->mNumCameras;
|
|
in.total += in.lights = sizeof(aiLight) * mScene->mNumLights;
|
|
|
|
// add all nodes
|
|
AddNodeWeight(in.nodes,mScene->mRootNode);
|
|
in.total += in.nodes;
|
|
|
|
// add all materials
|
|
for (unsigned int i = 0; i < mScene->mNumMaterials;++i) {
|
|
const aiMaterial* pc = mScene->mMaterials[i];
|
|
in.materials += sizeof(aiMaterial);
|
|
in.materials += pc->mNumAllocated * sizeof(void*);
|
|
|
|
for (unsigned int a = 0; a < pc->mNumProperties;++a) {
|
|
in.materials += pc->mProperties[a]->mDataLength;
|
|
}
|
|
}
|
|
in.total += in.materials;
|
|
}
|