diff --git a/code/BaseImporter.cpp b/code/BaseImporter.cpp index ae7588faa..a0de9c72e 100644 --- a/code/BaseImporter.cpp +++ b/code/BaseImporter.cpp @@ -52,6 +52,7 @@ using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer BaseImporter::BaseImporter() +: progress() { // nothing to do here } @@ -65,9 +66,15 @@ BaseImporter::~BaseImporter() // ------------------------------------------------------------------------------------------------ // Imports the given file and returns the imported data. -aiScene* BaseImporter::ReadFile( const std::string& pFile, IOSystem* pIOHandler) +aiScene* BaseImporter::ReadFile(const Importer* pImp, const std::string& pFile, IOSystem* pIOHandler) { - // Construct a file system filter to improve our success ratio reading external files + progress = pImp->GetProgressHandler(); + ai_assert(progress); + + // Gather configuration properties for this run + SetupProperties( pImp ); + + // Construct a file system filter to improve our success ratio at reading external files FileSystemFilter filter(pFile,pIOHandler); // create a scene object to hold the data diff --git a/code/BaseImporter.h b/code/BaseImporter.h index 8c7e2953c..54c679252 100644 --- a/code/BaseImporter.h +++ b/code/BaseImporter.h @@ -121,6 +121,10 @@ public: IOSystem* mIOHandler; bool mIsDefaultHandler; + /** Progress handler for feedback. */ + ProgressHandler* mProgressHandler; + bool mIsDefaultProgressHandler; + /** Format-specific importer worker objects - one for each format we can read.*/ std::vector mImporter; @@ -205,6 +209,7 @@ public: * takes care that any partially constructed data is destroyed * beforehand. * + * @param pImp #Importer object hosting this loader. * @param pFile Path of the file to be imported. * @param pIOHandler IO-Handler used to open this and possible other files. * @return The imported data or NULL if failed. If it failed a @@ -217,6 +222,7 @@ public: * a suitable response to the caller. */ aiScene* ReadFile( + const Importer* pImp, const std::string& pFile, IOSystem* pIOHandler ); @@ -396,6 +402,9 @@ protected: /** Error description in case there was one. */ std::string mErrorText; + + /** Currently set progress handler */ + ProgressHandler* progress; }; struct BatchData; diff --git a/code/BaseProcess.cpp b/code/BaseProcess.cpp index a1c1eea72..167f4f6a5 100644 --- a/code/BaseProcess.cpp +++ b/code/BaseProcess.cpp @@ -50,8 +50,9 @@ using namespace Assimp; // ------------------------------------------------------------------------------------------------ // Constructor to be privately used by Importer BaseProcess::BaseProcess() +: shared() +, progress() { - shared = NULL; } // ------------------------------------------------------------------------------------------------ @@ -64,7 +65,13 @@ BaseProcess::~BaseProcess() // ------------------------------------------------------------------------------------------------ void BaseProcess::ExecuteOnScene( Importer* pImp) { - ai_assert(NULL != pImp && NULL != pImp->pimpl->mScene) + ai_assert(NULL != pImp && NULL != pImp->pimpl->mScene); + + progress = pImp->GetProgressHandler(); + ai_assert(progress); + + SetupProperties( pImp ); + // catch exceptions thrown inside the PostProcess-Step try { diff --git a/code/BaseProcess.h b/code/BaseProcess.h index f325d30c7..c89d7b608 100644 --- a/code/BaseProcess.h +++ b/code/BaseProcess.h @@ -276,9 +276,11 @@ public: protected: - /** See the doc of #SharedPostProcessInfo for more details - */ + /** See the doc of #SharedPostProcessInfo for more details */ SharedPostProcessInfo* shared; + + /** Currently active progress handler */ + ProgressHandler* progress; }; diff --git a/code/CMakeLists.txt b/code/CMakeLists.txt index 866ba9753..103875d66 100644 --- a/code/CMakeLists.txt +++ b/code/CMakeLists.txt @@ -42,6 +42,7 @@ SET( PUBLIC_HEADERS ${HEADER_PATH}/assimp.h ${HEADER_PATH}/assimp.hpp ${HEADER_PATH}/DefaultLogger.h + ${HEADER_PATH}/ProgressHandler.h ${HEADER_PATH}/IOStream.h ${HEADER_PATH}/IOSystem.h ${HEADER_PATH}/Logger.h @@ -86,6 +87,7 @@ SOURCE_GROUP( Common FILES BaseProcess.h ByteSwap.h ProcessHelper.h + DefaultProgressHandler.h DefaultIOStream.cpp DefaultIOStream.h DefaultIOSystem.cpp @@ -493,6 +495,7 @@ ADD_LIBRARY( assimp SHARED DefaultIOStream.h DefaultIOSystem.cpp DefaultIOSystem.h + DefaultProgressHandler.h DefaultLogger.cpp FileLogStream.h FindDegenerates.cpp diff --git a/code/DefaultProgressHandler.h b/code/DefaultProgressHandler.h new file mode 100644 index 000000000..7cb6dd468 --- /dev/null +++ b/code/DefaultProgressHandler.h @@ -0,0 +1,64 @@ +/* +Open Asset Import Library (ASSIMP) +---------------------------------------------------------------------- + +Copyright (c) 2006-2010, ASSIMP Development 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 Development 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 ProgressHandler.h + * @brief Abstract base class 'ProgressHandler'. + */ +#ifndef INCLUDED_AI_DEFAULTPROGRESSHANDLER_H +#define INCLUDED_AI_DEFAULTPROGRESSHANDLER_H + +#include "../include/ProgressHandler.h" +namespace Assimp { + +// ------------------------------------------------------------------------------------ +/** @brief Internal default implementation of the #ProgressHandler interface. */ +class ASSIMP_API DefaultProgressHandler + : public ProgressHandler { + + + virtual bool Update(float percentage) { + return false; + } + + +}; // !class DefaultProgressHandler +} // Namespace Assimp + +#endif diff --git a/code/Importer.cpp b/code/Importer.cpp index 8ebf61732..fa0e33d8a 100644 --- a/code/Importer.cpp +++ b/code/Importer.cpp @@ -64,6 +64,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "BaseProcess.h" #include "DefaultIOStream.h" #include "DefaultIOSystem.h" +#include "DefaultProgressHandler.h" #include "GenericProperty.h" #include "ProcessHelper.h" #include "ScenePreprocessor.h" @@ -315,6 +316,9 @@ Importer::Importer() pimpl->mIsDefaultHandler = true; pimpl->bExtraVerbose = false; // disable extra verbose mode by default + pimpl->mProgressHandler = new DefaultProgressHandler(); + pimpl->mIsDefaultProgressHandler = true; + // ---------------------------------------------------------------------------- // Add an instance of each worker class here // (register_new_importers_here) @@ -623,7 +627,9 @@ aiReturn Importer::UnregisterLoader(BaseImporter* pImp) } ASSIMP_BEGIN_EXCEPTION_REGION(); - std::vector::iterator it = std::find(pimpl->mImporter.begin(),pimpl->mImporter.end(),pImp); + std::vector::iterator it = std::find(pimpl->mImporter.begin(), + pimpl->mImporter.end(),pImp); + if (it != pimpl->mImporter.end()) { pimpl->mImporter.erase(it); @@ -648,7 +654,9 @@ aiReturn Importer::UnregisterPPStep(BaseProcess* pImp) } ASSIMP_BEGIN_EXCEPTION_REGION(); - std::vector::iterator it = std::find(pimpl->mPostProcessingSteps.begin(),pimpl->mPostProcessingSteps.end(),pImp); + std::vector::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"); @@ -683,21 +691,57 @@ void Importer::SetIOHandler( IOSystem* pIOHandler) // ------------------------------------------------------------------------------------------------ // Get the currently set IO handler -IOSystem* Importer::GetIOHandler() +IOSystem* Importer::GetIOHandler() const { return pimpl->mIOHandler; } // ------------------------------------------------------------------------------------------------ // Check whether a custom IO handler is currently set -bool Importer::IsDefaultIOHandler() +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) +bool _ValidateFlags(unsigned int pFlags) { if (pFlags & aiProcess_GenSmoothNormals && pFlags & aiProcess_GenNormals) { DefaultLogger::get()->error("#aiProcess_GenSmoothNormals and #aiProcess_GenNormals are incompatible"); @@ -760,7 +804,7 @@ aiScene* Importer::GetOrphanedScene() // ------------------------------------------------------------------------------------------------ // Validate post-processing flags -bool Importer::ValidateFlags(unsigned int pFlags) +bool Importer::ValidateFlags(unsigned int pFlags) const { ASSIMP_BEGIN_EXCEPTION_REGION(); // run basic checks for mutually exclusive flags @@ -770,8 +814,9 @@ bool Importer::ValidateFlags(unsigned int pFlags) // 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) + if (pFlags & aiProcess_ValidateDataStructure) { return false; + } #endif pFlags &= ~aiProcess_ValidateDataStructure; @@ -789,8 +834,9 @@ bool Importer::ValidateFlags(unsigned int pFlags) break; } } - if (!have) + if (!have) { return false; + } } } ASSIMP_END_EXCEPTION_REGION(bool); @@ -953,13 +999,14 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) // Dispatch the reading to the worker class for this format DefaultLogger::get()->info("Found a matching importer for this file format"); + pimpl->mProgressHandler->Update(); if (profiler) { profiler->BeginRegion("import"); } - imp->SetupProperties( this ); - pimpl->mScene = imp->ReadFile( pFile, pimpl->mIOHandler); + pimpl->mScene = imp->ReadFile( this, pFile, pimpl->mIOHandler); + pimpl->mProgressHandler->Update(); if (profiler) { profiler->EndRegion("import"); @@ -988,6 +1035,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags) ScenePreprocessor pre(pimpl->mScene); pre.ProcessScene(); + pimpl->mProgressHandler->Update(); if (profiler) { profiler->EndRegion("preprocess"); } @@ -1083,8 +1131,8 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) profiler->BeginRegion("postprocess"); } - process->SetupProperties( this ); process->ExecuteOnScene ( this ); + pimpl->mProgressHandler->Update(); if (profiler) { profiler->EndRegion("postprocess"); @@ -1123,14 +1171,14 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags) // ------------------------------------------------------------------------------------------------ // Helper function to check whether an extension is supported by ASSIMP -bool Importer::IsExtensionSupported(const char* szExtension) +bool Importer::IsExtensionSupported(const char* szExtension) const { return NULL != FindLoader(szExtension); } // ------------------------------------------------------------------------------------------------ // Find a loader plugin for a given file extension -BaseImporter* Importer::FindLoader (const char* szExtension) +BaseImporter* Importer::FindLoader (const char* szExtension) const { ai_assert(szExtension); ASSIMP_BEGIN_EXCEPTION_REGION(); @@ -1159,7 +1207,7 @@ BaseImporter* Importer::FindLoader (const char* szExtension) // ------------------------------------------------------------------------------------------------ // Helper function to build a list of all file extensions supported by ASSIMP -void Importer::GetExtensionList(aiString& szOut) +void Importer::GetExtensionList(aiString& szOut) const { ASSIMP_BEGIN_EXCEPTION_REGION(); std::set str; diff --git a/include/ProgressHandler.h b/include/ProgressHandler.h new file mode 100644 index 000000000..1b435c9be --- /dev/null +++ b/include/ProgressHandler.h @@ -0,0 +1,93 @@ +/* +Open Asset Import Library (ASSIMP) +---------------------------------------------------------------------- + +Copyright (c) 2006-2010, ASSIMP Development 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 Development 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 ProgressHandler.h + * @brief Abstract base class 'ProgressHandler'. + */ +#ifndef INCLUDED_AI_PROGRESSHANDLER_H +#define INCLUDED_AI_PROGRESSHANDLER_H +#include "aiTypes.h" +namespace Assimp { + +// ------------------------------------------------------------------------------------ +/** @brief CPP-API: Abstract interface for custom progress report receivers. + * + * Each #Importer instance maintains its own #ProgressHandler. The default + * implementation provided by Assimp doesn't do anything at all. */ +class ASSIMP_API ProgressHandler + : public Intern::AllocateFromAssimpHeap { +protected: + /** @brief Default constructor */ + ProgressHandler () { + } +public: + /** @brief Virtual destructor */ + virtual ~ProgressHandler () { + } + + // ------------------------------------------------------------------- + /** @brief Progress callback. + * @param percentage An estimate of the current loading progress, + * in percent. Or -1.f if such an estimate is not available. + * + * There are restriction on what you may do from within your + * implementation of this method: no exceptions may be thrown and no + * non-const #Importer methods may be called. It is + * not generally possible to predict the number of callbacks + * fired during a single import. + * + * @return Return false to abort loading at the next possible + * occasion (loaders and Assimp are generally allowed to perform + * all needed cleanup tasks prior to returning control to the + * caller). If the loading is aborted, #Importer::ReadFile() + * returns always NULL. + * + * @note Currently, percentage is always -1.f because there is + * no reliable way to compute it. + * */ + virtual bool Update(float percentage = -1.f) = 0; + + + +}; // !class ProgressHandler +// ------------------------------------------------------------------------------------ +} // Namespace Assimp + +#endif diff --git a/include/assimp.hpp b/include/assimp.hpp index 9dc399493..5c89e58a2 100644 --- a/include/assimp.hpp +++ b/include/assimp.hpp @@ -60,6 +60,7 @@ namespace Assimp { class Importer; class IOStream; class IOSystem; + class ProgressHandler; // ======================================================================= // Plugin development @@ -298,21 +299,52 @@ public: // ------------------------------------------------------------------- /** Retrieves the IO handler that is currently set. - * You can use IsDefaultIOHandler() to check whether the returned + * You can use #IsDefaultIOHandler() to check whether the returned * interface is the default IO handler provided by ASSIMP. The default * handler is active as long the application doesn't supply its own - * custom IO handler via SetIOHandler(). - * @return A valid IOSystem interface + * custom IO handler via #SetIOHandler(). + * @return A valid IOSystem interface, never NULL. */ - IOSystem* GetIOHandler(); + IOSystem* GetIOHandler() const; // ------------------------------------------------------------------- /** Checks whether a default IO handler is active * A default handler is active as long the application doesn't - * supply its own custom IO handler via SetIOHandler(). + * supply its own custom IO handler via #SetIOHandler(). * @return true by default */ - bool IsDefaultIOHandler(); + bool IsDefaultIOHandler() const; + + // ------------------------------------------------------------------- + /** Supplies a custom progress handler to the importer. This + * interface exposes a #Update() callback, which is called + * more or less periodically (please don't sue us if it + * isn't as periodically as you'd like it to have ...). + * This can be used to implement progress bars and loading + * timeouts. + * @param pHandler Progress callback interface. Pass NULL to + * disable progress reporting. + * @note Progress handlers can be used to abort the loading + * at almost any time.*/ + void SetProgressHandler ( ProgressHandler* pHandler ); + + // ------------------------------------------------------------------- + /** Retrieves the progress handler that is currently set. + * You can use #IsDefaultProgressHandler() to check whether the returned + * interface is the default handler provided by ASSIMP. The default + * handler is active as long the application doesn't supply its own + * custom handler via #SetProgressHandler(). + * @return A valid ProgressHandler interface, never NULL. + */ + ProgressHandler* GetProgressHandler() const; + + // ------------------------------------------------------------------- + /** Checks whether a default progress handler is active + * A default handler is active as long the application doesn't + * supply its own custom progress handler via #SetProgressHandler(). + * @return true by default + */ + bool IsDefaultProgressHandler() const; // ------------------------------------------------------------------- /** @brief Check whether a given set of postprocessing flags @@ -324,9 +356,9 @@ public: * you're unsure. * * @param pFlags Bitwise combination of the aiPostProcess flags. - * @return true if this flag combination is not supported. + * @return true if this flag combination is fine. */ - bool ValidateFlags(unsigned int pFlags); + bool ValidateFlags(unsigned int pFlags) const; // ------------------------------------------------------------------- /** Reads the given file and returns its contents if successful. @@ -453,7 +485,7 @@ public: * Must include a trailing dot '.'. Example: ".3ds", ".md3". * Cases-insensitive. * @return true if the extension is supported, false otherwise */ - bool IsExtensionSupported(const char* szExtension); + bool IsExtensionSupported(const char* szExtension) const; // ------------------------------------------------------------------- /** @brief Returns whether a given file extension is supported by ASSIMP. @@ -461,7 +493,7 @@ public: * This function is provided for backward compatibility. * See the const char* version for detailed and up-to-date docs. * @see IsExtensionSupported(const char*) */ - inline bool IsExtensionSupported(const std::string& szExtension); + inline bool IsExtensionSupported(const std::string& szExtension) const; // ------------------------------------------------------------------- @@ -474,7 +506,7 @@ public: * @param szOut String to receive the extension list. * Format of the list: "*.3ds;*.obj;*.dae". This is useful for * use with the WinAPI call GetOpenFileName(Ex). */ - void GetExtensionList(aiString& szOut); + void GetExtensionList(aiString& szOut) const; // ------------------------------------------------------------------- /** @brief Get a full list of all file extensions supported by ASSIMP. @@ -482,7 +514,7 @@ public: * This function is provided for backward compatibility. * See the aiString version for detailed and up-to-date docs. * @see GetExtensionList(aiString&)*/ - inline void GetExtensionList(std::string& szOut); + inline void GetExtensionList(std::string& szOut) const; // ------------------------------------------------------------------- @@ -495,7 +527,7 @@ public: * is case-insensitive), ".bah", "*.bah" (wild card and dot * characters at the beginning of the extension are skipped). * @return NULL if there is no loader for the extension.*/ - BaseImporter* FindLoader (const char* szExtension); + BaseImporter* FindLoader (const char* szExtension) const; // ------------------------------------------------------------------- @@ -559,22 +591,17 @@ protected: // ---------------------------------------------------------------------------- // ---------------------------------------------------------------------------- -AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile, - unsigned int pFlags) -{ +AI_FORCE_INLINE const aiScene* Importer::ReadFile( const std::string& pFile,unsigned int pFlags){ return ReadFile(pFile.c_str(),pFlags); } // ---------------------------------------------------------------------------- -AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) -{ +AI_FORCE_INLINE void Importer::GetExtensionList(std::string& szOut) const { aiString s; GetExtensionList(s); szOut = s.data; } // ---------------------------------------------------------------------------- -AI_FORCE_INLINE bool Importer::IsExtensionSupported( - const std::string& szExtension) -{ +AI_FORCE_INLINE bool Importer::IsExtensionSupported(const std::string& szExtension) const { return IsExtensionSupported(szExtension.c_str()); } diff --git a/workspaces/vc9/assimp.sln b/workspaces/vc9/assimp.sln index 6b59b36f8..5d7d0be04 100644 --- a/workspaces/vc9/assimp.sln +++ b/workspaces/vc9/assimp.sln @@ -148,7 +148,8 @@ Global {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release|x64.ActiveCfg = Release|Win32 {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-dll|Win32.ActiveCfg = release-dll|Win32 {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-dll|Win32.Build.0 = release-dll|Win32 - {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-dll|x64.ActiveCfg = release-dll|Win32 + {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-dll|x64.ActiveCfg = release-dll|x64 + {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-dll|x64.Build.0 = release-dll|x64 {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-noboost-st|Win32.ActiveCfg = release-noboost-st|Win32 {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-noboost-st|Win32.Build.0 = release-noboost-st|Win32 {7C8F7B44-C990-4EA8-A2A5-9028472E0AD3}.release-noboost-st|x64.ActiveCfg = release-noboost-st|Win32 diff --git a/workspaces/vc9/assimp.vcproj b/workspaces/vc9/assimp.vcproj index e6e56cda3..0c76d5a63 100644 --- a/workspaces/vc9/assimp.vcproj +++ b/workspaces/vc9/assimp.vcproj @@ -1150,6 +1150,10 @@ RelativePath="..\..\include\NullLogger.h" > + + + + diff --git a/workspaces/vc9/assimp_cmd.vcproj b/workspaces/vc9/assimp_cmd.vcproj index 55b091309..a1f561bdb 100644 --- a/workspaces/vc9/assimp_cmd.vcproj +++ b/workspaces/vc9/assimp_cmd.vcproj @@ -458,7 +458,7 @@ />