diff --git a/CMakeLists.txt b/CMakeLists.txt index ecd131b8c..640f89e64 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -238,11 +238,6 @@ SET(LIBASSIMP-DEV_COMPONENT "libassimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_M SET(CPACK_COMPONENTS_ALL assimp-bin ${LIBASSIMP_COMPONENT} ${LIBASSIMP-DEV_COMPONENT} assimp-dev) SET(ASSIMP_LIBRARY_SUFFIX "" CACHE STRING "Suffix to append to library names") -IF( UNIX ) - # Use GNUInstallDirs for Unix predefined directories - INCLUDE(GNUInstallDirs) -ENDIF() - # Grouped compiler settings IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT CMAKE_COMPILER_IS_MINGW) IF(NOT ASSIMP_HUNTER_ENABLED) @@ -350,14 +345,6 @@ ELSE() SET(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin") ENDIF () -# Cache these to allow the user to override them manually. -SET( ASSIMP_LIB_INSTALL_DIR "lib" CACHE STRING - "Path the built library files are installed to." ) -SET( ASSIMP_INCLUDE_INSTALL_DIR "include" CACHE STRING - "Path the header files are installed to." ) -SET( ASSIMP_BIN_INSTALL_DIR "bin" CACHE STRING - "Path the tool executables are installed to." ) - get_cmake_property(is_multi_config GENERATOR_IS_MULTI_CONFIG) IF (ASSIMP_INJECT_DEBUG_POSTFIX AND (is_multi_config OR CMAKE_BUILD_TYPE STREQUAL "Debug")) @@ -417,6 +404,28 @@ ELSE() else() set(BUILD_LIB_TYPE STATIC) endif() + + IF( UNIX ) + # Use GNUInstallDirs for Unix predefined directories + INCLUDE(GNUInstallDirs) + + SET( ASSIMP_LIB_INSTALL_DIR ${CMAKE_INSTALL_LIBDIR}) + SET( ASSIMP_INCLUDE_INSTALL_DIR ${CMAKE_INSTALL_INCLUDEDIR}) + SET( ASSIMP_BIN_INSTALL_DIR ${CMAKE_INSTALL_BINDIR}) + ELSE() + # Cache these to allow the user to override them on non-Unix platforms + SET( ASSIMP_LIB_INSTALL_DIR "lib" CACHE STRING + "Path the built library files are installed to." ) + SET( ASSIMP_INCLUDE_INSTALL_DIR "include" CACHE STRING + "Path the header files are installed to." ) + SET( ASSIMP_BIN_INSTALL_DIR "bin" CACHE STRING + "Path the tool executables are installed to." ) + + SET(CMAKE_INSTALL_FULL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX}/${ASSIMP_INCLUDE_INSTALL_DIR}) + SET(CMAKE_INSTALL_FULL_LIBDIR ${CMAKE_INSTALL_PREFIX}/${ASSIMP_LIB_INSTALL_DIR}) + SET(CMAKE_INSTALL_FULL_BINDIR ${CMAKE_INSTALL_PREFIX}/${ASSIMP_BIN_INSTALL_DIR}) + ENDIF() + CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" @ONLY IMMEDIATE) CONFIGURE_FILE("${CMAKE_CURRENT_SOURCE_DIR}/assimpTargets.cmake.in" "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake" @ONLY IMMEDIATE) IF (is_multi_config) diff --git a/assimp.pc.in b/assimp.pc.in index 02cf59dc4..555a3a1d3 100644 --- a/assimp.pc.in +++ b/assimp.pc.in @@ -1,7 +1,5 @@ -prefix=@CMAKE_INSTALL_PREFIX@ -exec_prefix=@CMAKE_INSTALL_PREFIX@/ -libdir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_LIB_INSTALL_DIR@ -includedir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_INCLUDE_INSTALL_DIR@ +libdir=@CMAKE_INSTALL_FULL_LIBDIR@ +includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@ Name: @CMAKE_PROJECT_NAME@ Description: Import various well-known 3D model formats in an uniform manner. diff --git a/assimpTargets-debug.cmake.in b/assimpTargets-debug.cmake.in index 4cb917fd8..2488c1f57 100644 --- a/assimpTargets-debug.cmake.in +++ b/assimpTargets-debug.cmake.in @@ -44,22 +44,22 @@ if(MSVC) # Import target "assimp::assimp" for configuration "Debug" set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) set_target_properties(assimp::assimp PROPERTIES - IMPORTED_IMPLIB_DEBUG "${_IMPORT_PREFIX}/lib/${importLibraryName}" - IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" + IMPORTED_IMPLIB_DEBUG "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}" + IMPORTED_LOCATION_DEBUG "@CMAKE_INSTALL_FULL_BINDIR@/${sharedLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}") - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}") + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_BINDIR@/${sharedLibraryName}" ) else() set(staticLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_STATIC_LIBRARY_SUFFIX@") # Import target "assimp::assimp" for configuration "Debug" set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS DEBUG) set_target_properties(assimp::assimp PROPERTIES - IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + IMPORTED_LOCATION_DEBUG "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}") + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}") endif() else() @@ -75,17 +75,17 @@ else() endif() set_target_properties(assimp::assimp PROPERTIES IMPORTED_SONAME_DEBUG "${sharedLibraryName}" - IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" + IMPORTED_LOCATION_DEBUG "@CMAKE_INSTALL_FULL_LIBDIR@/${sharedLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${sharedLibraryName}" ) else() set(staticLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_STATIC_LIBRARY_SUFFIX@") set_target_properties(assimp::assimp PROPERTIES - IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + IMPORTED_LOCATION_DEBUG "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}" ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}" ) endif() endif() diff --git a/assimpTargets-release.cmake.in b/assimpTargets-release.cmake.in index 702109305..a4555e326 100644 --- a/assimpTargets-release.cmake.in +++ b/assimpTargets-release.cmake.in @@ -44,12 +44,12 @@ if(MSVC) # Import target "assimp::assimp" for configuration "Release" set_property(TARGET assimp::assimp APPEND PROPERTY IMPORTED_CONFIGURATIONS RELEASE) set_target_properties(assimp::assimp PROPERTIES - IMPORTED_IMPLIB_RELEASE "${_IMPORT_PREFIX}/lib/${importLibraryName}" - IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" + IMPORTED_IMPLIB_RELEASE "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}" + IMPORTED_LOCATION_RELEASE "@CMAKE_INSTALL_FULL_BINDIR@/${sharedLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${importLibraryName}") - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}") + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_BINDIR@/${sharedLibraryName}" ) else() set(staticLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_STATIC_LIBRARY_SUFFIX@") @@ -59,7 +59,7 @@ if(MSVC) IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${staticLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}") + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}") endif() else() @@ -75,18 +75,17 @@ else() endif() set_target_properties(assimp::assimp PROPERTIES IMPORTED_SONAME_RELEASE "${sharedLibraryName}" - - IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" + IMPORTED_LOCATION_RELEASE "@CMAKE_INSTALL_FULL_LIBDIR@/${sharedLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${sharedLibraryName}" ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${sharedLibraryName}" ) else() set(staticLibraryName "libassimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_STATIC_LIBRARY_SUFFIX@") set_target_properties(assimp::assimp PROPERTIES - IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${staticLibraryName}" + IMPORTED_LOCATION_RELEASE "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}" ) list(APPEND _IMPORT_CHECK_TARGETS assimp::assimp ) - list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/lib/${staticLibraryName}" ) + list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "@CMAKE_INSTALL_FULL_LIBDIR@/${staticLibraryName}" ) endif() endif() diff --git a/assimpTargets.cmake.in b/assimpTargets.cmake.in index b1c618c3a..897d00217 100644 --- a/assimpTargets.cmake.in +++ b/assimpTargets.cmake.in @@ -43,23 +43,13 @@ unset(_targetsDefined) unset(_targetsNotDefined) unset(_expectedTargets) - -# Compute the installation prefix relative to this file. -get_filename_component(_IMPORT_PREFIX "${CMAKE_CURRENT_LIST_FILE}" PATH) -get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) -get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) -get_filename_component(_IMPORT_PREFIX "${_IMPORT_PREFIX}" PATH) -if(_IMPORT_PREFIX STREQUAL "/") - set(_IMPORT_PREFIX "") -endif() - # Create imported target assimp::assimp add_library(assimp::assimp @BUILD_LIB_TYPE@ IMPORTED) set_target_properties(assimp::assimp PROPERTIES COMPATIBLE_INTERFACE_STRING "assimp_MAJOR_VERSION" INTERFACE_assimp_MAJOR_VERSION "1" - INTERFACE_INCLUDE_DIRECTORIES "${_IMPORT_PREFIX}/include;${_IMPORT_PREFIX}/include" + INTERFACE_INCLUDE_DIRECTORIES "@CMAKE_INSTALL_FULL_INCLUDEDIR@" #INTERFACE_LINK_LIBRARIES "TxtUtils::TxtUtils;MealyMachine::MealyMachine" ) @@ -74,9 +64,6 @@ foreach(f ${CONFIG_FILES}) include(${f}) endforeach() -# Cleanup temporary variables. -set(_IMPORT_PREFIX) - # Loop over all imported files and verify that they actually exist foreach(target ${_IMPORT_CHECK_TARGETS} ) foreach(file ${_IMPORT_CHECK_FILES_FOR_${target}} ) diff --git a/code/Common/Assimp.cpp b/code/Common/Assimp.cpp index 7dae2633c..67f1c3af2 100644 --- a/code/Common/Assimp.cpp +++ b/code/Common/Assimp.cpp @@ -44,15 +44,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * @brief Implementation of the Plain-C API */ +#include +#include +#include #include -#include -#include -#include #include #include -#include -#include -#include +#include +#include +#include #include "CApi/CInterfaceIOWrapper.h" #include "Importer.h" @@ -62,46 +62,45 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. // ------------------------------------------------------------------------------------------------ #ifndef ASSIMP_BUILD_SINGLETHREADED -# include -# include +#include +#include #endif // ------------------------------------------------------------------------------------------------ using namespace Assimp; namespace Assimp { - // underlying structure for aiPropertyStore - typedef BatchLoader::PropertyMap PropertyMap; +// underlying structure for aiPropertyStore +typedef BatchLoader::PropertyMap PropertyMap; - /** Stores the LogStream objects for all active C log streams */ - struct mpred { - bool operator () (const aiLogStream& s0, const aiLogStream& s1) const { - return s0.callback LogStreamMap; +/** Stores the LogStream objects for all active C log streams */ +struct mpred { + bool operator()(const aiLogStream &s0, const aiLogStream &s1) const { + return s0.callback < s1.callback && s0.user < s1.user; + } +}; +typedef std::map LogStreamMap; - /** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */ - typedef std::list PredefLogStreamMap; +/** Stores the LogStream objects allocated by #aiGetPredefinedLogStream */ +typedef std::list PredefLogStreamMap; - /** Local storage of all active log streams */ - static LogStreamMap gActiveLogStreams; +/** Local storage of all active log streams */ +static LogStreamMap gActiveLogStreams; - /** Local storage of LogStreams allocated by #aiGetPredefinedLogStream */ - static PredefLogStreamMap gPredefinedStreams; +/** Local storage of LogStreams allocated by #aiGetPredefinedLogStream */ +static PredefLogStreamMap gPredefinedStreams; - /** Error message of the last failed import process */ - static std::string gLastErrorString; +/** Error message of the last failed import process */ +static std::string gLastErrorString; - /** Verbose logging active or not? */ - static aiBool gVerboseLogging = false; +/** Verbose logging active or not? */ +static aiBool gVerboseLogging = false; - /** will return all registered importers. */ - void GetImporterInstanceList(std::vector< BaseImporter* >& out); - - /** will delete all registered importers. */ - void DeleteImporterInstanceList(std::vector< BaseImporter* >& out); -} // namespace assimp +/** will return all registered importers. */ +void GetImporterInstanceList(std::vector &out); +/** will delete all registered importers. */ +void DeleteImporterInstanceList(std::vector &out); +} // namespace Assimp #ifndef ASSIMP_BUILD_SINGLETHREADED /** Global mutex to manage the access to the log-stream map */ @@ -112,12 +111,12 @@ static std::mutex gLogStreamMutex; // Custom LogStream implementation for the C-API class LogToCallbackRedirector : public LogStream { public: - explicit LogToCallbackRedirector(const aiLogStream& s) - : stream (s) { + explicit LogToCallbackRedirector(const aiLogStream &s) : + stream(s) { ai_assert(NULL != s.callback); } - ~LogToCallbackRedirector() { + ~LogToCallbackRedirector() { #ifndef ASSIMP_BUILD_SINGLETHREADED std::lock_guard lock(gLogStreamMutex); #endif @@ -127,7 +126,7 @@ public: // might cause strange problems, but the chance is quite low. PredefLogStreamMap::iterator it = std::find(gPredefinedStreams.begin(), - gPredefinedStreams.end(), (Assimp::LogStream*)stream.user); + gPredefinedStreams.end(), (Assimp::LogStream *)stream.user); if (it != gPredefinedStreams.end()) { delete *it; @@ -136,8 +135,8 @@ public: } /** @copydoc LogStream::write */ - void write(const char* message) { - stream.callback(message,stream.user); + void write(const char *message) { + stream.callback(message, stream.user); } private: @@ -147,37 +146,37 @@ private: // ------------------------------------------------------------------------------------------------ void ReportSceneNotFoundError() { 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); } // ------------------------------------------------------------------------------------------------ // Reads the given file and returns its content. -const aiScene* aiImportFile( const char* pFile, unsigned int pFlags) { - return aiImportFileEx(pFile,pFlags,NULL); +const aiScene *aiImportFile(const char *pFile, unsigned int pFlags) { + return aiImportFileEx(pFile, pFlags, NULL); } // ------------------------------------------------------------------------------------------------ -const aiScene* aiImportFileEx( const char* pFile, unsigned int pFlags, aiFileIO* pFS) { +const aiScene *aiImportFileEx(const char *pFile, unsigned int pFlags, aiFileIO *pFS) { return aiImportFileExWithProperties(pFile, pFlags, pFS, NULL); } // ------------------------------------------------------------------------------------------------ -const aiScene* aiImportFileExWithProperties( const char* pFile, unsigned int pFlags, - aiFileIO* pFS, const aiPropertyStore* props) { +const aiScene *aiImportFileExWithProperties(const char *pFile, unsigned int pFlags, + aiFileIO *pFS, const aiPropertyStore *props) { ai_assert(NULL != pFile); - const aiScene* scene = NULL; + const aiScene *scene = NULL; ASSIMP_BEGIN_EXCEPTION_REGION(); // create an Importer for this file - Assimp::Importer* imp = new Assimp::Importer(); + Assimp::Importer *imp = new Assimp::Importer(); // copy properties - if(props) { - const PropertyMap* pp = reinterpret_cast(props); - ImporterPimpl* pimpl = imp->Pimpl(); + if (props) { + const PropertyMap *pp = reinterpret_cast(props); + ImporterPimpl *pimpl = imp->Pimpl(); pimpl->mIntProperties = pp->ints; pimpl->mFloatProperties = pp->floats; pimpl->mStringProperties = pp->strings; @@ -185,15 +184,15 @@ const aiScene* aiImportFileExWithProperties( const char* pFile, unsigned int pFl } // setup a custom IO system if necessary if (pFS) { - imp->SetIOHandler( new CIOSystemWrapper (pFS) ); + imp->SetIOHandler(new CIOSystemWrapper(pFS)); } // and have it read the file - scene = imp->ReadFile( pFile, pFlags); + scene = imp->ReadFile(pFile, pFlags); // if succeeded, store the importer in the scene and keep it alive - if( scene) { - ScenePrivateData* priv = const_cast( ScenePriv(scene) ); + if (scene) { + ScenePrivateData *priv = const_cast(ScenePriv(scene)); priv->mOrigImporter = imp; } else { // if failed, extract error code and destroy the import @@ -202,42 +201,40 @@ const aiScene* aiImportFileExWithProperties( const char* pFile, unsigned int pFl } // return imported data. If the import failed the pointer is NULL anyways - ASSIMP_END_EXCEPTION_REGION(const aiScene*); - + ASSIMP_END_EXCEPTION_REGION(const aiScene *); + return scene; } // ------------------------------------------------------------------------------------------------ -const aiScene* aiImportFileFromMemory( - const char* pBuffer, - unsigned int pLength, - unsigned int pFlags, - const char* pHint) -{ +const aiScene *aiImportFileFromMemory( + const char *pBuffer, + unsigned int pLength, + unsigned int pFlags, + const char *pHint) { return aiImportFileFromMemoryWithProperties(pBuffer, pLength, pFlags, pHint, NULL); } // ------------------------------------------------------------------------------------------------ -const aiScene* aiImportFileFromMemoryWithProperties( - const char* pBuffer, - unsigned int pLength, - unsigned int pFlags, - const char* pHint, - const aiPropertyStore* props) -{ - ai_assert( NULL != pBuffer ); - ai_assert( 0 != pLength ); +const aiScene *aiImportFileFromMemoryWithProperties( + const char *pBuffer, + unsigned int pLength, + unsigned int pFlags, + const char *pHint, + const aiPropertyStore *props) { + ai_assert(NULL != pBuffer); + ai_assert(0 != pLength); - const aiScene* scene = NULL; + const aiScene *scene = NULL; ASSIMP_BEGIN_EXCEPTION_REGION(); // create an Importer for this file - Assimp::Importer* imp = new Assimp::Importer(); + Assimp::Importer *imp = new Assimp::Importer(); // copy properties - if(props) { - const PropertyMap* pp = reinterpret_cast(props); - ImporterPimpl* pimpl = imp->Pimpl(); + if (props) { + const PropertyMap *pp = reinterpret_cast(props); + ImporterPimpl *pimpl = imp->Pimpl(); pimpl->mIntProperties = pp->ints; pimpl->mFloatProperties = pp->floats; pimpl->mStringProperties = pp->strings; @@ -245,27 +242,25 @@ const aiScene* aiImportFileFromMemoryWithProperties( } // and have it read the file from the memory buffer - scene = imp->ReadFileFromMemory( pBuffer, pLength, pFlags,pHint); + scene = imp->ReadFileFromMemory(pBuffer, pLength, pFlags, pHint); // if succeeded, store the importer in the scene and keep it alive - if( scene) { - ScenePrivateData* priv = const_cast( ScenePriv(scene) ); - priv->mOrigImporter = imp; - } - else { + if (scene) { + ScenePrivateData *priv = const_cast(ScenePriv(scene)); + priv->mOrigImporter = imp; + } else { // if failed, extract error code and destroy the import gLastErrorString = imp->GetErrorString(); delete imp; } // return imported data. If the import failed the pointer is NULL anyways - ASSIMP_END_EXCEPTION_REGION(const aiScene*); + ASSIMP_END_EXCEPTION_REGION(const aiScene *); return scene; } // ------------------------------------------------------------------------------------------------ // Releases all resources associated with the given import process. -void aiReleaseImport( const aiScene* pScene) -{ +void aiReleaseImport(const aiScene *pScene) { if (!pScene) { return; } @@ -273,15 +268,14 @@ void aiReleaseImport( const aiScene* pScene) ASSIMP_BEGIN_EXCEPTION_REGION(); // find the importer associated with this data - const ScenePrivateData* priv = ScenePriv(pScene); - if( !priv || !priv->mOrigImporter) { + const ScenePrivateData *priv = ScenePriv(pScene); + if (!priv || !priv->mOrigImporter) { delete pScene; - } - else { + } else { // deleting the Importer also deletes the scene // Note: the reason that this is not written as 'delete priv->mOrigImporter' // is a suspected bug in gcc 4.4+ (http://gcc.gnu.org/bugzilla/show_bug.cgi?id=52339) - Importer* importer = priv->mOrigImporter; + Importer *importer = priv->mOrigImporter; delete importer; } @@ -289,17 +283,15 @@ void aiReleaseImport( const aiScene* pScene) } // ------------------------------------------------------------------------------------------------ -ASSIMP_API const aiScene* aiApplyPostProcessing(const aiScene* pScene, - unsigned int pFlags) -{ - const aiScene* sc = NULL; - +ASSIMP_API const aiScene *aiApplyPostProcessing(const aiScene *pScene, + unsigned int pFlags) { + const aiScene *sc = NULL; ASSIMP_BEGIN_EXCEPTION_REGION(); // find the importer associated with this data - const ScenePrivateData* priv = ScenePriv(pScene); - if( !priv || !priv->mOrigImporter) { + const ScenePrivateData *priv = ScenePriv(pScene); + if (!priv || !priv->mOrigImporter) { ReportSceneNotFoundError(); return NULL; } @@ -311,61 +303,58 @@ ASSIMP_API const aiScene* aiApplyPostProcessing(const aiScene* pScene, return NULL; } - ASSIMP_END_EXCEPTION_REGION(const aiScene*); + ASSIMP_END_EXCEPTION_REGION(const aiScene *); return sc; } // ------------------------------------------------------------------------------------------------ -ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene, - BaseProcess* process, - bool requestValidation ) { - const aiScene* sc( NULL ); +ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing(const aiScene *scene, + BaseProcess *process, + bool requestValidation) { + const aiScene *sc(NULL); ASSIMP_BEGIN_EXCEPTION_REGION(); // find the importer associated with this data - const ScenePrivateData* priv = ScenePriv( scene ); - if ( NULL == priv || NULL == priv->mOrigImporter ) { + const ScenePrivateData *priv = ScenePriv(scene); + if (NULL == priv || NULL == priv->mOrigImporter) { ReportSceneNotFoundError(); return NULL; } - sc = priv->mOrigImporter->ApplyCustomizedPostProcessing( process, requestValidation ); + sc = priv->mOrigImporter->ApplyCustomizedPostProcessing(process, requestValidation); - if ( !sc ) { - aiReleaseImport( scene ); + if (!sc) { + aiReleaseImport(scene); return NULL; } - ASSIMP_END_EXCEPTION_REGION( const aiScene* ); + ASSIMP_END_EXCEPTION_REGION(const aiScene *); return sc; } // ------------------------------------------------------------------------------------------------ -void CallbackToLogRedirector (const char* msg, char* dt) -{ - ai_assert( NULL != msg ); - ai_assert( NULL != dt ); - LogStream* s = (LogStream*)dt; +void CallbackToLogRedirector(const char *msg, char *dt) { + ai_assert(NULL != msg); + ai_assert(NULL != dt); + LogStream *s = (LogStream *)dt; s->write(msg); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const char* file) -{ +ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) { aiLogStream sout; ASSIMP_BEGIN_EXCEPTION_REGION(); - LogStream* stream = LogStream::createDefaultStream(pStream,file); + LogStream *stream = LogStream::createDefaultStream(pStream, file); if (!stream) { sout.callback = NULL; sout.user = NULL; - } - else { + } else { sout.callback = &CallbackToLogRedirector; - sout.user = (char*)stream; + sout.user = (char *)stream; } gPredefinedStreams.push_back(stream); ASSIMP_END_EXCEPTION_REGION(aiLogStream); @@ -373,42 +362,40 @@ ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiAttachLogStream( const aiLogStream* stream ) -{ +ASSIMP_API void aiAttachLogStream(const aiLogStream *stream) { ASSIMP_BEGIN_EXCEPTION_REGION(); #ifndef ASSIMP_BUILD_SINGLETHREADED std::lock_guard lock(gLogStreamMutex); #endif - LogStream* lg = new LogToCallbackRedirector(*stream); + LogStream *lg = new LogToCallbackRedirector(*stream); gActiveLogStreams[*stream] = lg; if (DefaultLogger::isNullLogger()) { - DefaultLogger::create(NULL,(gVerboseLogging == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL)); + DefaultLogger::create(NULL, (gVerboseLogging == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL)); } DefaultLogger::get()->attachStream(lg); ASSIMP_END_EXCEPTION_REGION(void); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream) -{ +ASSIMP_API aiReturn aiDetachLogStream(const aiLogStream *stream) { ASSIMP_BEGIN_EXCEPTION_REGION(); #ifndef ASSIMP_BUILD_SINGLETHREADED std::lock_guard lock(gLogStreamMutex); #endif // find the log-stream associated with this data - LogStreamMap::iterator it = gActiveLogStreams.find( *stream); + LogStreamMap::iterator it = gActiveLogStreams.find(*stream); // it should be there... else the user is playing fools with us - if( it == gActiveLogStreams.end()) { + if (it == gActiveLogStreams.end()) { return AI_FAILURE; } - DefaultLogger::get()->detatchStream( it->second ); + DefaultLogger::get()->detatchStream(it->second); delete it->second; - gActiveLogStreams.erase( it); + gActiveLogStreams.erase(it); if (gActiveLogStreams.empty()) { DefaultLogger::kill(); @@ -418,19 +405,18 @@ ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream) } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiDetachAllLogStreams(void) -{ +ASSIMP_API void aiDetachAllLogStreams(void) { ASSIMP_BEGIN_EXCEPTION_REGION(); #ifndef ASSIMP_BUILD_SINGLETHREADED std::lock_guard lock(gLogStreamMutex); #endif - Logger *logger( DefaultLogger::get() ); - if ( NULL == logger ) { + Logger *logger(DefaultLogger::get()); + if (NULL == logger) { return; } for (LogStreamMap::iterator it = gActiveLogStreams.begin(); it != gActiveLogStreams.end(); ++it) { - logger->detatchStream( it->second ); + logger->detatchStream(it->second); delete it->second; } gActiveLogStreams.clear(); @@ -440,8 +426,7 @@ ASSIMP_API void aiDetachAllLogStreams(void) } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiEnableVerboseLogging(aiBool d) -{ +ASSIMP_API void aiEnableVerboseLogging(aiBool d) { if (!DefaultLogger::isNullLogger()) { DefaultLogger::get()->setLogSeverity((d == AI_TRUE ? Logger::VERBOSE : Logger::NORMAL)); } @@ -450,31 +435,27 @@ ASSIMP_API void aiEnableVerboseLogging(aiBool d) // ------------------------------------------------------------------------------------------------ // Returns the error text of the last failed import process. -const char* aiGetErrorString() -{ +const char *aiGetErrorString() { return gLastErrorString.c_str(); } // ----------------------------------------------------------------------------------------------- // Return the description of a importer given its index -const aiImporterDesc* aiGetImportFormatDescription( size_t pIndex) -{ +const aiImporterDesc *aiGetImportFormatDescription(size_t pIndex) { return Importer().GetImporterInfo(pIndex); } // ----------------------------------------------------------------------------------------------- // Return the number of importers -size_t aiGetImportFormatCount(void) -{ +size_t aiGetImportFormatCount(void) { return Importer().GetImporterCount(); } // ------------------------------------------------------------------------------------------------ // Returns the error text of the last failed import process. -aiBool aiIsExtensionSupported(const char* szExtension) -{ +aiBool aiIsExtensionSupported(const char *szExtension) { ai_assert(NULL != szExtension); - aiBool candoit=AI_FALSE; + aiBool candoit = AI_FALSE; ASSIMP_BEGIN_EXCEPTION_REGION(); // FIXME: no need to create a temporary Importer instance just for that .. @@ -487,8 +468,7 @@ aiBool aiIsExtensionSupported(const char* szExtension) // ------------------------------------------------------------------------------------------------ // Get a list of all file extensions supported by ASSIMP -void aiGetExtensionList(aiString* szOut) -{ +void aiGetExtensionList(aiString *szOut) { ai_assert(NULL != szOut); ASSIMP_BEGIN_EXCEPTION_REGION(); @@ -501,14 +481,13 @@ void aiGetExtensionList(aiString* szOut) // ------------------------------------------------------------------------------------------------ // Get the memory requirements for a particular import. -void aiGetMemoryRequirements(const C_STRUCT aiScene* pIn, - C_STRUCT aiMemoryInfo* in) -{ +void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn, + C_STRUCT aiMemoryInfo *in) { ASSIMP_BEGIN_EXCEPTION_REGION(); // find the importer associated with this data - const ScenePrivateData* priv = ScenePriv(pIn); - if( !priv || !priv->mOrigImporter) { + const ScenePrivateData *priv = ScenePriv(pIn); + if (!priv || !priv->mOrigImporter) { ReportSceneNotFoundError(); return; } @@ -518,118 +497,106 @@ void aiGetMemoryRequirements(const C_STRUCT aiScene* pIn, } // ------------------------------------------------------------------------------------------------ -ASSIMP_API aiPropertyStore* aiCreatePropertyStore(void) -{ - return reinterpret_cast( new PropertyMap() ); +ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) { + return reinterpret_cast(new PropertyMap()); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiReleasePropertyStore(aiPropertyStore* p) -{ - delete reinterpret_cast(p); +ASSIMP_API void aiReleasePropertyStore(aiPropertyStore *p) { + delete reinterpret_cast(p); } // ------------------------------------------------------------------------------------------------ // Importer::SetPropertyInteger -ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szName, int value) -{ +ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore *p, const char *szName, int value) { ASSIMP_BEGIN_EXCEPTION_REGION(); - PropertyMap* pp = reinterpret_cast(p); - SetGenericProperty(pp->ints,szName,value); + PropertyMap *pp = reinterpret_cast(p); + SetGenericProperty(pp->ints, szName, value); ASSIMP_END_EXCEPTION_REGION(void); } // ------------------------------------------------------------------------------------------------ // Importer::SetPropertyFloat -ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName, ai_real value) -{ +ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore *p, const char *szName, ai_real value) { ASSIMP_BEGIN_EXCEPTION_REGION(); - PropertyMap* pp = reinterpret_cast(p); - SetGenericProperty(pp->floats,szName,value); + PropertyMap *pp = reinterpret_cast(p); + SetGenericProperty(pp->floats, szName, value); ASSIMP_END_EXCEPTION_REGION(void); } // ------------------------------------------------------------------------------------------------ // Importer::SetPropertyString -ASSIMP_API void aiSetImportPropertyString(aiPropertyStore* p, const char* szName, - const C_STRUCT aiString* st) -{ +ASSIMP_API void aiSetImportPropertyString(aiPropertyStore *p, const char *szName, + const C_STRUCT aiString *st) { if (!st) { return; } ASSIMP_BEGIN_EXCEPTION_REGION(); - PropertyMap* pp = reinterpret_cast(p); - SetGenericProperty(pp->strings,szName,std::string(st->C_Str())); + PropertyMap *pp = reinterpret_cast(p); + SetGenericProperty(pp->strings, szName, std::string(st->C_Str())); ASSIMP_END_EXCEPTION_REGION(void); } // ------------------------------------------------------------------------------------------------ // Importer::SetPropertyMatrix -ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore* p, const char* szName, - const C_STRUCT aiMatrix4x4* mat) -{ +ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore *p, const char *szName, + const C_STRUCT aiMatrix4x4 *mat) { if (!mat) { return; } ASSIMP_BEGIN_EXCEPTION_REGION(); - PropertyMap* pp = reinterpret_cast(p); - SetGenericProperty(pp->matrices,szName,*mat); + PropertyMap *pp = reinterpret_cast(p); + SetGenericProperty(pp->matrices, szName, *mat); ASSIMP_END_EXCEPTION_REGION(void); } // ------------------------------------------------------------------------------------------------ // Rotation matrix to quaternion -ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion* quat,const aiMatrix3x3* mat) -{ - ai_assert( NULL != quat ); - ai_assert( NULL != mat ); +ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion *quat, const aiMatrix3x3 *mat) { + ai_assert(NULL != quat); + ai_assert(NULL != mat); *quat = aiQuaternion(*mat); } // ------------------------------------------------------------------------------------------------ // Matrix decomposition -ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4* mat,aiVector3D* scaling, - aiQuaternion* rotation, - aiVector3D* position) -{ - ai_assert( NULL != rotation ); - ai_assert( NULL != position ); - ai_assert( NULL != scaling ); - ai_assert( NULL != mat ); - mat->Decompose(*scaling,*rotation,*position); +ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4 *mat, aiVector3D *scaling, + aiQuaternion *rotation, + aiVector3D *position) { + ai_assert(NULL != rotation); + ai_assert(NULL != position); + ai_assert(NULL != scaling); + ai_assert(NULL != mat); + mat->Decompose(*scaling, *rotation, *position); } // ------------------------------------------------------------------------------------------------ // Matrix transpose -ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3* mat) -{ +ASSIMP_API void aiTransposeMatrix3(aiMatrix3x3 *mat) { ai_assert(NULL != mat); mat->Transpose(); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4* mat) -{ +ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4 *mat) { ai_assert(NULL != mat); mat->Transpose(); } // ------------------------------------------------------------------------------------------------ // Vector transformation -ASSIMP_API void aiTransformVecByMatrix3(aiVector3D* vec, - const aiMatrix3x3* mat) -{ - ai_assert( NULL != mat ); - ai_assert( NULL != vec); +ASSIMP_API void aiTransformVecByMatrix3(aiVector3D *vec, + const aiMatrix3x3 *mat) { + ai_assert(NULL != mat); + ai_assert(NULL != vec); *vec *= (*mat); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiTransformVecByMatrix4(aiVector3D* vec, - const aiMatrix4x4* mat) -{ - ai_assert( NULL != mat ); - ai_assert( NULL != vec ); +ASSIMP_API void aiTransformVecByMatrix4(aiVector3D *vec, + const aiMatrix4x4 *mat) { + ai_assert(NULL != mat); + ai_assert(NULL != vec); *vec *= (*mat); } @@ -637,52 +604,48 @@ ASSIMP_API void aiTransformVecByMatrix4(aiVector3D* vec, // ------------------------------------------------------------------------------------------------ // Matrix multiplication ASSIMP_API void aiMultiplyMatrix4( - aiMatrix4x4* dst, - const aiMatrix4x4* src) -{ - ai_assert( NULL != dst ); - ai_assert( NULL != src ); + aiMatrix4x4 *dst, + const aiMatrix4x4 *src) { + ai_assert(NULL != dst); + ai_assert(NULL != src); *dst = (*dst) * (*src); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMultiplyMatrix3( - aiMatrix3x3* dst, - const aiMatrix3x3* src) -{ - ai_assert( NULL != dst ); - ai_assert( NULL != src ); + aiMatrix3x3 *dst, + const aiMatrix3x3 *src) { + ai_assert(NULL != dst); + ai_assert(NULL != src); *dst = (*dst) * (*src); } // ------------------------------------------------------------------------------------------------ // Matrix identity ASSIMP_API void aiIdentityMatrix3( - aiMatrix3x3* mat) -{ + aiMatrix3x3 *mat) { ai_assert(NULL != mat); *mat = aiMatrix3x3(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiIdentityMatrix4( - aiMatrix4x4* mat) -{ + aiMatrix4x4 *mat) { ai_assert(NULL != mat); *mat = aiMatrix4x4(); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API C_STRUCT const aiImporterDesc* aiGetImporterDesc( const char *extension ) { - if( NULL == extension ) { +ASSIMP_API C_STRUCT const aiImporterDesc *aiGetImporterDesc(const char *extension) { + if (NULL == extension) { return NULL; } - const aiImporterDesc *desc( NULL ); - std::vector< BaseImporter* > out; - GetImporterInstanceList( out ); - for( size_t i = 0; i < out.size(); ++i ) { - if( 0 == strncmp( out[ i ]->GetInfo()->mFileExtensions, extension, strlen( extension ) ) ) { - desc = out[ i ]->GetInfo(); + const aiImporterDesc *desc(NULL); + std::vector out; + GetImporterInstanceList(out); + for (size_t i = 0; i < out.size(); ++i) { + if (0 == strncmp(out[i]->GetInfo()->mFileExtensions, extension, strlen(extension))) { + desc = out[i]->GetInfo(); break; } } @@ -694,8 +657,8 @@ ASSIMP_API C_STRUCT const aiImporterDesc* aiGetImporterDesc( const char *extensi // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiVector2AreEqual( - const C_STRUCT aiVector2D* a, - const C_STRUCT aiVector2D* b) { + const C_STRUCT aiVector2D *a, + const C_STRUCT aiVector2D *b) { ai_assert(NULL != a); ai_assert(NULL != b); return *a == *b; @@ -703,9 +666,9 @@ ASSIMP_API int aiVector2AreEqual( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiVector2AreEqualEpsilon( - const C_STRUCT aiVector2D* a, - const C_STRUCT aiVector2D* b, - const float epsilon) { + const C_STRUCT aiVector2D *a, + const C_STRUCT aiVector2D *b, + const float epsilon) { ai_assert(NULL != a); ai_assert(NULL != b); return a->Equal(*b, epsilon); @@ -713,8 +676,8 @@ ASSIMP_API int aiVector2AreEqualEpsilon( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2Add( - C_STRUCT aiVector2D* dst, - const C_STRUCT aiVector2D* src) { + C_STRUCT aiVector2D *dst, + const C_STRUCT aiVector2D *src) { ai_assert(NULL != dst); ai_assert(NULL != src); *dst = *dst + *src; @@ -722,8 +685,8 @@ ASSIMP_API void aiVector2Add( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2Subtract( - C_STRUCT aiVector2D* dst, - const C_STRUCT aiVector2D* src) { + C_STRUCT aiVector2D *dst, + const C_STRUCT aiVector2D *src) { ai_assert(NULL != dst); ai_assert(NULL != src); *dst = *dst - *src; @@ -731,16 +694,16 @@ ASSIMP_API void aiVector2Subtract( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2Scale( - C_STRUCT aiVector2D* dst, - const float s) { + C_STRUCT aiVector2D *dst, + const float s) { ai_assert(NULL != dst); *dst *= s; } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2SymMul( - C_STRUCT aiVector2D* dst, - const C_STRUCT aiVector2D* other) { + C_STRUCT aiVector2D *dst, + const C_STRUCT aiVector2D *other) { ai_assert(NULL != dst); ai_assert(NULL != other); *dst = dst->SymMul(*other); @@ -748,16 +711,16 @@ ASSIMP_API void aiVector2SymMul( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2DivideByScalar( - C_STRUCT aiVector2D* dst, - const float s) { + C_STRUCT aiVector2D *dst, + const float s) { ai_assert(NULL != dst); *dst /= s; } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2DivideByVector( - C_STRUCT aiVector2D* dst, - C_STRUCT aiVector2D* v) { + C_STRUCT aiVector2D *dst, + C_STRUCT aiVector2D *v) { ai_assert(NULL != dst); ai_assert(NULL != v); *dst = *dst / *v; @@ -765,29 +728,29 @@ ASSIMP_API void aiVector2DivideByVector( // ------------------------------------------------------------------------------------------------ ASSIMP_API float aiVector2Length( - const C_STRUCT aiVector2D* v) { + const C_STRUCT aiVector2D *v) { ai_assert(NULL != v); return v->Length(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API float aiVector2SquareLength( - const C_STRUCT aiVector2D* v) { + const C_STRUCT aiVector2D *v) { ai_assert(NULL != v); return v->SquareLength(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2Negate( - C_STRUCT aiVector2D* dst) { + C_STRUCT aiVector2D *dst) { ai_assert(NULL != dst); *dst = -(*dst); } // ------------------------------------------------------------------------------------------------ ASSIMP_API float aiVector2DotProduct( - const C_STRUCT aiVector2D* a, - const C_STRUCT aiVector2D* b) { + const C_STRUCT aiVector2D *a, + const C_STRUCT aiVector2D *b) { ai_assert(NULL != a); ai_assert(NULL != b); return (*a) * (*b); @@ -795,15 +758,15 @@ ASSIMP_API float aiVector2DotProduct( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector2Normalize( - C_STRUCT aiVector2D* v) { + C_STRUCT aiVector2D *v) { ai_assert(NULL != v); v->Normalize(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiVector3AreEqual( - const C_STRUCT aiVector3D* a, - const C_STRUCT aiVector3D* b) { + const C_STRUCT aiVector3D *a, + const C_STRUCT aiVector3D *b) { ai_assert(NULL != a); ai_assert(NULL != b); return *a == *b; @@ -811,9 +774,9 @@ ASSIMP_API int aiVector3AreEqual( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiVector3AreEqualEpsilon( - const C_STRUCT aiVector3D* a, - const C_STRUCT aiVector3D* b, - const float epsilon) { + const C_STRUCT aiVector3D *a, + const C_STRUCT aiVector3D *b, + const float epsilon) { ai_assert(NULL != a); ai_assert(NULL != b); return a->Equal(*b, epsilon); @@ -821,8 +784,8 @@ ASSIMP_API int aiVector3AreEqualEpsilon( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiVector3LessThan( - const C_STRUCT aiVector3D* a, - const C_STRUCT aiVector3D* b) { + const C_STRUCT aiVector3D *a, + const C_STRUCT aiVector3D *b) { ai_assert(NULL != a); ai_assert(NULL != b); return *a < *b; @@ -830,8 +793,8 @@ ASSIMP_API int aiVector3LessThan( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3Add( - C_STRUCT aiVector3D* dst, - const C_STRUCT aiVector3D* src) { + C_STRUCT aiVector3D *dst, + const C_STRUCT aiVector3D *src) { ai_assert(NULL != dst); ai_assert(NULL != src); *dst = *dst + *src; @@ -839,8 +802,8 @@ ASSIMP_API void aiVector3Add( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3Subtract( - C_STRUCT aiVector3D* dst, - const C_STRUCT aiVector3D* src) { + C_STRUCT aiVector3D *dst, + const C_STRUCT aiVector3D *src) { ai_assert(NULL != dst); ai_assert(NULL != src); *dst = *dst - *src; @@ -848,16 +811,16 @@ ASSIMP_API void aiVector3Subtract( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3Scale( - C_STRUCT aiVector3D* dst, - const float s) { + C_STRUCT aiVector3D *dst, + const float s) { ai_assert(NULL != dst); *dst *= s; } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3SymMul( - C_STRUCT aiVector3D* dst, - const C_STRUCT aiVector3D* other) { + C_STRUCT aiVector3D *dst, + const C_STRUCT aiVector3D *other) { ai_assert(NULL != dst); ai_assert(NULL != other); *dst = dst->SymMul(*other); @@ -865,15 +828,15 @@ ASSIMP_API void aiVector3SymMul( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3DivideByScalar( - C_STRUCT aiVector3D* dst, const float s) { + C_STRUCT aiVector3D *dst, const float s) { ai_assert(NULL != dst); *dst /= s; } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3DivideByVector( - C_STRUCT aiVector3D* dst, - C_STRUCT aiVector3D* v) { + C_STRUCT aiVector3D *dst, + C_STRUCT aiVector3D *v) { ai_assert(NULL != dst); ai_assert(NULL != v); *dst = *dst / *v; @@ -881,29 +844,29 @@ ASSIMP_API void aiVector3DivideByVector( // ------------------------------------------------------------------------------------------------ ASSIMP_API float aiVector3Length( - const C_STRUCT aiVector3D* v) { + const C_STRUCT aiVector3D *v) { ai_assert(NULL != v); return v->Length(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API float aiVector3SquareLength( - const C_STRUCT aiVector3D* v) { + const C_STRUCT aiVector3D *v) { ai_assert(NULL != v); return v->SquareLength(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3Negate( - C_STRUCT aiVector3D* dst) { + C_STRUCT aiVector3D *dst) { ai_assert(NULL != dst); *dst = -(*dst); } // ------------------------------------------------------------------------------------------------ ASSIMP_API float aiVector3DotProduct( - const C_STRUCT aiVector3D* a, - const C_STRUCT aiVector3D* b) { + const C_STRUCT aiVector3D *a, + const C_STRUCT aiVector3D *b) { ai_assert(NULL != a); ai_assert(NULL != b); return (*a) * (*b); @@ -911,9 +874,9 @@ ASSIMP_API float aiVector3DotProduct( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3CrossProduct( - C_STRUCT aiVector3D* dst, - const C_STRUCT aiVector3D* a, - const C_STRUCT aiVector3D* b) { + C_STRUCT aiVector3D *dst, + const C_STRUCT aiVector3D *a, + const C_STRUCT aiVector3D *b) { ai_assert(NULL != dst); ai_assert(NULL != a); ai_assert(NULL != b); @@ -922,22 +885,22 @@ ASSIMP_API void aiVector3CrossProduct( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3Normalize( - C_STRUCT aiVector3D* v) { + C_STRUCT aiVector3D *v) { ai_assert(NULL != v); v->Normalize(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3NormalizeSafe( - C_STRUCT aiVector3D* v) { + C_STRUCT aiVector3D *v) { ai_assert(NULL != v); v->NormalizeSafe(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiVector3RotateByQuaternion( - C_STRUCT aiVector3D* v, - const C_STRUCT aiQuaternion* q) { + C_STRUCT aiVector3D *v, + const C_STRUCT aiQuaternion *q) { ai_assert(NULL != v); ai_assert(NULL != q); *v = q->Rotate(*v); @@ -945,8 +908,8 @@ ASSIMP_API void aiVector3RotateByQuaternion( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix3FromMatrix4( - C_STRUCT aiMatrix3x3* dst, - const C_STRUCT aiMatrix4x4* mat) { + C_STRUCT aiMatrix3x3 *dst, + const C_STRUCT aiMatrix4x4 *mat) { ai_assert(NULL != dst); ai_assert(NULL != mat); *dst = aiMatrix3x3(*mat); @@ -954,8 +917,8 @@ ASSIMP_API void aiMatrix3FromMatrix4( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix3FromQuaternion( - C_STRUCT aiMatrix3x3* mat, - const C_STRUCT aiQuaternion* q) { + C_STRUCT aiMatrix3x3 *mat, + const C_STRUCT aiQuaternion *q) { ai_assert(NULL != mat); ai_assert(NULL != q); *mat = q->GetMatrix(); @@ -963,8 +926,8 @@ ASSIMP_API void aiMatrix3FromQuaternion( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiMatrix3AreEqual( - const C_STRUCT aiMatrix3x3* a, - const C_STRUCT aiMatrix3x3* b) { + const C_STRUCT aiMatrix3x3 *a, + const C_STRUCT aiMatrix3x3 *b) { ai_assert(NULL != a); ai_assert(NULL != b); return *a == *b; @@ -972,39 +935,39 @@ ASSIMP_API int aiMatrix3AreEqual( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiMatrix3AreEqualEpsilon( - const C_STRUCT aiMatrix3x3* a, - const C_STRUCT aiMatrix3x3* b, - const float epsilon) { + const C_STRUCT aiMatrix3x3 *a, + const C_STRUCT aiMatrix3x3 *b, + const float epsilon) { ai_assert(NULL != a); ai_assert(NULL != b); return a->Equal(*b, epsilon); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiMatrix3Inverse(C_STRUCT aiMatrix3x3* mat) { +ASSIMP_API void aiMatrix3Inverse(C_STRUCT aiMatrix3x3 *mat) { ai_assert(NULL != mat); mat->Inverse(); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API float aiMatrix3Determinant(const C_STRUCT aiMatrix3x3* mat) { +ASSIMP_API float aiMatrix3Determinant(const C_STRUCT aiMatrix3x3 *mat) { ai_assert(NULL != mat); return mat->Determinant(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix3RotationZ( - C_STRUCT aiMatrix3x3* mat, - const float angle) { + C_STRUCT aiMatrix3x3 *mat, + const float angle) { ai_assert(NULL != mat); aiMatrix3x3::RotationZ(angle, *mat); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix3FromRotationAroundAxis( - C_STRUCT aiMatrix3x3* mat, - const C_STRUCT aiVector3D* axis, - const float angle) { + C_STRUCT aiMatrix3x3 *mat, + const C_STRUCT aiVector3D *axis, + const float angle) { ai_assert(NULL != mat); ai_assert(NULL != axis); aiMatrix3x3::Rotation(angle, *axis, *mat); @@ -1012,8 +975,8 @@ ASSIMP_API void aiMatrix3FromRotationAroundAxis( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix3Translation( - C_STRUCT aiMatrix3x3* mat, - const C_STRUCT aiVector2D* translation) { + C_STRUCT aiMatrix3x3 *mat, + const C_STRUCT aiVector2D *translation) { ai_assert(NULL != mat); ai_assert(NULL != translation); aiMatrix3x3::Translation(*translation, *mat); @@ -1021,9 +984,9 @@ ASSIMP_API void aiMatrix3Translation( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix3FromTo( - C_STRUCT aiMatrix3x3* mat, - const C_STRUCT aiVector3D* from, - const C_STRUCT aiVector3D* to) { + C_STRUCT aiMatrix3x3 *mat, + const C_STRUCT aiVector3D *from, + const C_STRUCT aiVector3D *to) { ai_assert(NULL != mat); ai_assert(NULL != from); ai_assert(NULL != to); @@ -1032,8 +995,8 @@ ASSIMP_API void aiMatrix3FromTo( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4FromMatrix3( - C_STRUCT aiMatrix4x4* dst, - const C_STRUCT aiMatrix3x3* mat) { + C_STRUCT aiMatrix4x4 *dst, + const C_STRUCT aiMatrix3x3 *mat) { ai_assert(NULL != dst); ai_assert(NULL != mat); *dst = aiMatrix4x4(*mat); @@ -1041,10 +1004,10 @@ ASSIMP_API void aiMatrix4FromMatrix3( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4FromScalingQuaternionPosition( - C_STRUCT aiMatrix4x4* mat, - const C_STRUCT aiVector3D* scaling, - const C_STRUCT aiQuaternion* rotation, - const C_STRUCT aiVector3D* position) { + C_STRUCT aiMatrix4x4 *mat, + const C_STRUCT aiVector3D *scaling, + const C_STRUCT aiQuaternion *rotation, + const C_STRUCT aiVector3D *position) { ai_assert(NULL != mat); ai_assert(NULL != scaling); ai_assert(NULL != rotation); @@ -1054,8 +1017,8 @@ ASSIMP_API void aiMatrix4FromScalingQuaternionPosition( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4Add( - C_STRUCT aiMatrix4x4* dst, - const C_STRUCT aiMatrix4x4* src) { + C_STRUCT aiMatrix4x4 *dst, + const C_STRUCT aiMatrix4x4 *src) { ai_assert(NULL != dst); ai_assert(NULL != src); *dst = *dst + *src; @@ -1063,8 +1026,8 @@ ASSIMP_API void aiMatrix4Add( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiMatrix4AreEqual( - const C_STRUCT aiMatrix4x4* a, - const C_STRUCT aiMatrix4x4* b) { + const C_STRUCT aiMatrix4x4 *a, + const C_STRUCT aiMatrix4x4 *b) { ai_assert(NULL != a); ai_assert(NULL != b); return *a == *b; @@ -1072,38 +1035,38 @@ ASSIMP_API int aiMatrix4AreEqual( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiMatrix4AreEqualEpsilon( - const C_STRUCT aiMatrix4x4* a, - const C_STRUCT aiMatrix4x4* b, - const float epsilon) { + const C_STRUCT aiMatrix4x4 *a, + const C_STRUCT aiMatrix4x4 *b, + const float epsilon) { ai_assert(NULL != a); ai_assert(NULL != b); return a->Equal(*b, epsilon); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API void aiMatrix4Inverse(C_STRUCT aiMatrix4x4* mat) { +ASSIMP_API void aiMatrix4Inverse(C_STRUCT aiMatrix4x4 *mat) { ai_assert(NULL != mat); mat->Inverse(); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API float aiMatrix4Determinant(const C_STRUCT aiMatrix4x4* mat) { +ASSIMP_API float aiMatrix4Determinant(const C_STRUCT aiMatrix4x4 *mat) { ai_assert(NULL != mat); return mat->Determinant(); } // ------------------------------------------------------------------------------------------------ -ASSIMP_API int aiMatrix4IsIdentity(const C_STRUCT aiMatrix4x4* mat) { +ASSIMP_API int aiMatrix4IsIdentity(const C_STRUCT aiMatrix4x4 *mat) { ai_assert(NULL != mat); return mat->IsIdentity(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4DecomposeIntoScalingEulerAnglesPosition( - const C_STRUCT aiMatrix4x4* mat, - C_STRUCT aiVector3D* scaling, - C_STRUCT aiVector3D* rotation, - C_STRUCT aiVector3D* position) { + const C_STRUCT aiMatrix4x4 *mat, + C_STRUCT aiVector3D *scaling, + C_STRUCT aiVector3D *rotation, + C_STRUCT aiVector3D *position) { ai_assert(NULL != mat); ai_assert(NULL != scaling); ai_assert(NULL != rotation); @@ -1113,11 +1076,11 @@ ASSIMP_API void aiMatrix4DecomposeIntoScalingEulerAnglesPosition( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition( - const C_STRUCT aiMatrix4x4* mat, - C_STRUCT aiVector3D* scaling, - C_STRUCT aiVector3D* axis, - float* angle, - C_STRUCT aiVector3D* position) { + const C_STRUCT aiMatrix4x4 *mat, + C_STRUCT aiVector3D *scaling, + C_STRUCT aiVector3D *axis, + float *angle, + C_STRUCT aiVector3D *position) { ai_assert(NULL != mat); ai_assert(NULL != scaling); ai_assert(NULL != axis); @@ -1128,9 +1091,9 @@ ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4DecomposeNoScaling( - const C_STRUCT aiMatrix4x4* mat, - C_STRUCT aiQuaternion* rotation, - C_STRUCT aiVector3D* position) { + const C_STRUCT aiMatrix4x4 *mat, + C_STRUCT aiQuaternion *rotation, + C_STRUCT aiVector3D *position) { ai_assert(NULL != mat); ai_assert(NULL != rotation); ai_assert(NULL != position); @@ -1139,41 +1102,41 @@ ASSIMP_API void aiMatrix4DecomposeNoScaling( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4FromEulerAngles( - C_STRUCT aiMatrix4x4* mat, - float x, float y, float z) { + C_STRUCT aiMatrix4x4 *mat, + float x, float y, float z) { ai_assert(NULL != mat); mat->FromEulerAnglesXYZ(x, y, z); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4RotationX( - C_STRUCT aiMatrix4x4* mat, - const float angle) { + C_STRUCT aiMatrix4x4 *mat, + const float angle) { ai_assert(NULL != mat); aiMatrix4x4::RotationX(angle, *mat); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4RotationY( - C_STRUCT aiMatrix4x4* mat, - const float angle) { + C_STRUCT aiMatrix4x4 *mat, + const float angle) { ai_assert(NULL != mat); aiMatrix4x4::RotationY(angle, *mat); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4RotationZ( - C_STRUCT aiMatrix4x4* mat, - const float angle) { + C_STRUCT aiMatrix4x4 *mat, + const float angle) { ai_assert(NULL != mat); aiMatrix4x4::RotationZ(angle, *mat); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4FromRotationAroundAxis( - C_STRUCT aiMatrix4x4* mat, - const C_STRUCT aiVector3D* axis, - const float angle) { + C_STRUCT aiMatrix4x4 *mat, + const C_STRUCT aiVector3D *axis, + const float angle) { ai_assert(NULL != mat); ai_assert(NULL != axis); aiMatrix4x4::Rotation(angle, *axis, *mat); @@ -1181,8 +1144,8 @@ ASSIMP_API void aiMatrix4FromRotationAroundAxis( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4Translation( - C_STRUCT aiMatrix4x4* mat, - const C_STRUCT aiVector3D* translation) { + C_STRUCT aiMatrix4x4 *mat, + const C_STRUCT aiVector3D *translation) { ai_assert(NULL != mat); ai_assert(NULL != translation); aiMatrix4x4::Translation(*translation, *mat); @@ -1190,8 +1153,8 @@ ASSIMP_API void aiMatrix4Translation( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4Scaling( - C_STRUCT aiMatrix4x4* mat, - const C_STRUCT aiVector3D* scaling) { + C_STRUCT aiMatrix4x4 *mat, + const C_STRUCT aiVector3D *scaling) { ai_assert(NULL != mat); ai_assert(NULL != scaling); aiMatrix4x4::Scaling(*scaling, *mat); @@ -1199,9 +1162,9 @@ ASSIMP_API void aiMatrix4Scaling( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiMatrix4FromTo( - C_STRUCT aiMatrix4x4* mat, - const C_STRUCT aiVector3D* from, - const C_STRUCT aiVector3D* to) { + C_STRUCT aiMatrix4x4 *mat, + const C_STRUCT aiVector3D *from, + const C_STRUCT aiVector3D *to) { ai_assert(NULL != mat); ai_assert(NULL != from); ai_assert(NULL != to); @@ -1210,17 +1173,17 @@ ASSIMP_API void aiMatrix4FromTo( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionFromEulerAngles( - C_STRUCT aiQuaternion* q, - float x, float y, float z) { + C_STRUCT aiQuaternion *q, + float x, float y, float z) { ai_assert(NULL != q); *q = aiQuaternion(x, y, z); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionFromAxisAngle( - C_STRUCT aiQuaternion* q, - const C_STRUCT aiVector3D* axis, - const float angle) { + C_STRUCT aiQuaternion *q, + const C_STRUCT aiVector3D *axis, + const float angle) { ai_assert(NULL != q); ai_assert(NULL != axis); *q = aiQuaternion(*axis, angle); @@ -1228,8 +1191,8 @@ ASSIMP_API void aiQuaternionFromAxisAngle( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionFromNormalizedQuaternion( - C_STRUCT aiQuaternion* q, - const C_STRUCT aiVector3D* normalized) { + C_STRUCT aiQuaternion *q, + const C_STRUCT aiVector3D *normalized) { ai_assert(NULL != q); ai_assert(NULL != normalized); *q = aiQuaternion(*normalized); @@ -1237,8 +1200,8 @@ ASSIMP_API void aiQuaternionFromNormalizedQuaternion( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiQuaternionAreEqual( - const C_STRUCT aiQuaternion* a, - const C_STRUCT aiQuaternion* b) { + const C_STRUCT aiQuaternion *a, + const C_STRUCT aiQuaternion *b) { ai_assert(NULL != a); ai_assert(NULL != b); return *a == *b; @@ -1246,9 +1209,9 @@ ASSIMP_API int aiQuaternionAreEqual( // ------------------------------------------------------------------------------------------------ ASSIMP_API int aiQuaternionAreEqualEpsilon( - const C_STRUCT aiQuaternion* a, - const C_STRUCT aiQuaternion* b, - const float epsilon) { + const C_STRUCT aiQuaternion *a, + const C_STRUCT aiQuaternion *b, + const float epsilon) { ai_assert(NULL != a); ai_assert(NULL != b); return a->Equal(*b, epsilon); @@ -1256,22 +1219,22 @@ ASSIMP_API int aiQuaternionAreEqualEpsilon( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionNormalize( - C_STRUCT aiQuaternion* q) { + C_STRUCT aiQuaternion *q) { ai_assert(NULL != q); q->Normalize(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionConjugate( - C_STRUCT aiQuaternion* q) { + C_STRUCT aiQuaternion *q) { ai_assert(NULL != q); q->Conjugate(); } // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionMultiply( - C_STRUCT aiQuaternion* dst, - const C_STRUCT aiQuaternion* q) { + C_STRUCT aiQuaternion *dst, + const C_STRUCT aiQuaternion *q) { ai_assert(NULL != dst); ai_assert(NULL != q); *dst = (*dst) * (*q); @@ -1279,10 +1242,10 @@ ASSIMP_API void aiQuaternionMultiply( // ------------------------------------------------------------------------------------------------ ASSIMP_API void aiQuaternionInterpolate( - C_STRUCT aiQuaternion* dst, - const C_STRUCT aiQuaternion* start, - const C_STRUCT aiQuaternion* end, - const float factor) { + C_STRUCT aiQuaternion *dst, + const C_STRUCT aiQuaternion *start, + const C_STRUCT aiQuaternion *end, + const float factor) { ai_assert(NULL != dst); ai_assert(NULL != start); ai_assert(NULL != end); diff --git a/code/FBX/FBXImportSettings.h b/code/FBX/FBXImportSettings.h index 974931b4c..ec6d7ccc1 100644 --- a/code/FBX/FBXImportSettings.h +++ b/code/FBX/FBXImportSettings.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -50,27 +49,25 @@ namespace Assimp { namespace FBX { /** FBX import settings, parts of which are publicly accessible via their corresponding AI_CONFIG constants */ -struct ImportSettings -{ - ImportSettings() - : strictMode(true) - , readAllLayers(true) - , readAllMaterials(false) - , readMaterials(true) - , readTextures(true) - , readCameras(true) - , readLights(true) - , readAnimations(true) - , readWeights(true) - , preservePivots(true) - , optimizeEmptyAnimationCurves(true) - , useLegacyEmbeddedTextureNaming(false) - , removeEmptyBones( true ) - , convertToMeters( false ) { +struct ImportSettings { + ImportSettings() : + strictMode(true), + readAllLayers(true), + readAllMaterials(false), + readMaterials(true), + readTextures(true), + readCameras(true), + readLights(true), + readAnimations(true), + readWeights(true), + preservePivots(true), + optimizeEmptyAnimationCurves(true), + useLegacyEmbeddedTextureNaming(false), + removeEmptyBones(true), + convertToMeters(false) { // empty } - /** enable strict mode: * - only accept fbx 2012, 2013 files * - on the slightest error, give up. @@ -94,7 +91,6 @@ struct ImportSettings * This bit is ignored unless readMaterials=true*/ bool readAllMaterials; - /** import materials (true) or skip them and assign a default * material. The default value is true.*/ bool readMaterials; @@ -156,9 +152,7 @@ struct ImportSettings bool convertToMeters; }; - -} // !FBX -} // !Assimp +} // namespace FBX +} // namespace Assimp #endif - diff --git a/code/FBX/FBXImporter.cpp b/code/FBX/FBXImporter.cpp index 571f60883..11c1503d8 100644 --- a/code/FBX/FBXImporter.cpp +++ b/code/FBX/FBXImporter.cpp @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, diff --git a/code/FBX/FBXImporter.h b/code/FBX/FBXImporter.h index 63375e40d..7a9fc4b74 100644 --- a/code/FBX/FBXImporter.h +++ b/code/FBX/FBXImporter.h @@ -4,7 +4,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -51,45 +50,44 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "FBXImportSettings.h" -namespace Assimp { +namespace Assimp { // TinyFormatter.h namespace Formatter { - template class basic_formatter; - typedef class basic_formatter< char, std::char_traits, std::allocator > format; -} + +template +class basic_formatter; + +typedef class basic_formatter, std::allocator> format; + +} // namespace Formatter // ------------------------------------------------------------------------------------------- -/** Load the Autodesk FBX file format. - - See http://en.wikipedia.org/wiki/FBX -*/ +/// Loads the Autodesk FBX file format. +/// +/// See http://en.wikipedia.org/wiki/FBX // ------------------------------------------------------------------------------------------- -class FBXImporter : public BaseImporter, public LogFunctions -{ +class FBXImporter : public BaseImporter, public LogFunctions { public: FBXImporter(); virtual ~FBXImporter(); // -------------------- - bool CanRead( const std::string& pFile, - IOSystem* pIOHandler, - bool checkSig - ) const; + bool CanRead(const std::string &pFile, + IOSystem *pIOHandler, + bool checkSig) const; protected: + // -------------------- + const aiImporterDesc *GetInfo() const; // -------------------- - const aiImporterDesc* GetInfo () const; + void SetupProperties(const Importer *pImp); // -------------------- - void SetupProperties(const Importer* pImp); - - // -------------------- - void InternReadFile( const std::string& pFile, - aiScene* pScene, - IOSystem* pIOHandler - ); + void InternReadFile(const std::string &pFile, + aiScene *pScene, + IOSystem *pIOHandler); private: FBX::ImportSettings settings; @@ -97,4 +95,3 @@ private: } // end of namespace Assimp #endif // !INCLUDED_AI_FBX_IMPORTER_H - diff --git a/include/assimp/metadata.h b/include/assimp/metadata.h index bddd04b1e..28ddce567 100644 --- a/include/assimp/metadata.h +++ b/include/assimp/metadata.h @@ -5,8 +5,6 @@ Open Asset Import Library (assimp) Copyright (c) 2006-2020, assimp team - - All rights reserved. Redistribution and use of this software in source and binary forms, @@ -49,29 +47,29 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #define AI_METADATA_H_INC #ifdef __GNUC__ -# pragma GCC system_header +#pragma GCC system_header #endif #if defined(_MSC_VER) && (_MSC_VER <= 1500) -# include "Compiler/pstdint.h" +#include "Compiler/pstdint.h" #else -# include +#include #endif // ------------------------------------------------------------------------------- /** * Enum used to distinguish data types */ - // ------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------- typedef enum aiMetadataType { - AI_BOOL = 0, - AI_INT32 = 1, - AI_UINT64 = 2, - AI_FLOAT = 3, - AI_DOUBLE = 4, - AI_AISTRING = 5, + AI_BOOL = 0, + AI_INT32 = 1, + AI_UINT64 = 2, + AI_FLOAT = 3, + AI_DOUBLE = 4, + AI_AISTRING = 5, AI_AIVECTOR3D = 6, - AI_META_MAX = 7, + AI_META_MAX = 7, #ifndef SWIG FORCE_32BIT = INT_MAX @@ -84,10 +82,10 @@ typedef enum aiMetadataType { * * The type field uniquely identifies the underlying type of the data field */ - // ------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------- struct aiMetadataEntry { aiMetadataType mType; - void* mData; + void *mData; }; #ifdef __cplusplus @@ -98,15 +96,29 @@ struct aiMetadataEntry { /** * Helper functions to get the aiType enum entry for a type */ - // ------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------- -inline aiMetadataType GetAiType( bool ) { return AI_BOOL; } -inline aiMetadataType GetAiType( int32_t ) { return AI_INT32; } -inline aiMetadataType GetAiType( uint64_t ) { return AI_UINT64; } -inline aiMetadataType GetAiType( float ) { return AI_FLOAT; } -inline aiMetadataType GetAiType( double ) { return AI_DOUBLE; } -inline aiMetadataType GetAiType( const aiString & ) { return AI_AISTRING; } -inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; } +inline aiMetadataType GetAiType(bool) { + return AI_BOOL; +} +inline aiMetadataType GetAiType(int32_t) { + return AI_INT32; +} +inline aiMetadataType GetAiType(uint64_t) { + return AI_UINT64; +} +inline aiMetadataType GetAiType(float) { + return AI_FLOAT; +} +inline aiMetadataType GetAiType(double) { + return AI_DOUBLE; +} +inline aiMetadataType GetAiType(const aiString &) { + return AI_AISTRING; +} +inline aiMetadataType GetAiType(const aiVector3D &) { + return AI_AIVECTOR3D; +} #endif // __cplusplus @@ -116,17 +128,17 @@ inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; } * * Metadata is a key-value store using string keys and values. */ - // ------------------------------------------------------------------------------- +// ------------------------------------------------------------------------------- struct aiMetadata { /** Length of the mKeys and mValues arrays, respectively */ unsigned int mNumProperties; /** Arrays of keys, may not be NULL. Entries in this array may not be NULL as well. */ - C_STRUCT aiString* mKeys; + C_STRUCT aiString *mKeys; /** Arrays of values, may not be NULL. Entries in this array may be NULL if the * corresponding property key has no assigned value. */ - C_STRUCT aiMetadataEntry* mValues; + C_STRUCT aiMetadataEntry *mValues; #ifdef __cplusplus @@ -134,71 +146,62 @@ struct aiMetadata { * @brief The default constructor, set all members to zero by default. */ aiMetadata() AI_NO_EXCEPT - : mNumProperties(0) - , mKeys(nullptr) - , mValues(nullptr) { + : mNumProperties(0), + mKeys(nullptr), + mValues(nullptr) { // empty } - aiMetadata( const aiMetadata &rhs ) - : mNumProperties( rhs.mNumProperties ) - , mKeys( nullptr ) - , mValues( nullptr ) { - mKeys = new aiString[ mNumProperties ]; - for ( size_t i = 0; i < static_cast( mNumProperties ); ++i ) { - mKeys[ i ] = rhs.mKeys[ i ]; + aiMetadata(const aiMetadata &rhs) : + mNumProperties(rhs.mNumProperties), mKeys(nullptr), mValues(nullptr) { + mKeys = new aiString[mNumProperties]; + for (size_t i = 0; i < static_cast(mNumProperties); ++i) { + mKeys[i] = rhs.mKeys[i]; } - mValues = new aiMetadataEntry[ mNumProperties ]; - for ( size_t i = 0; i < static_cast(mNumProperties); ++i ) { - mValues[ i ].mType = rhs.mValues[ i ].mType; - switch ( rhs.mValues[ i ].mType ) { + mValues = new aiMetadataEntry[mNumProperties]; + for (size_t i = 0; i < static_cast(mNumProperties); ++i) { + mValues[i].mType = rhs.mValues[i].mType; + switch (rhs.mValues[i].mType) { case AI_BOOL: - mValues[ i ].mData = new bool; - ::memcpy( mValues[ i ].mData, rhs.mValues[ i ].mData, sizeof(bool) ); + mValues[i].mData = new bool; + ::memcpy(mValues[i].mData, rhs.mValues[i].mData, sizeof(bool)); break; case AI_INT32: { int32_t v; - ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( int32_t ) ); - mValues[ i ].mData = new int32_t( v ); - } - break; + ::memcpy(&v, rhs.mValues[i].mData, sizeof(int32_t)); + mValues[i].mData = new int32_t(v); + } break; case AI_UINT64: { - uint64_t v; - ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( uint64_t ) ); - mValues[ i ].mData = new uint64_t( v ); - } - break; + uint64_t v; + ::memcpy(&v, rhs.mValues[i].mData, sizeof(uint64_t)); + mValues[i].mData = new uint64_t(v); + } break; case AI_FLOAT: { - float v; - ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( float ) ); - mValues[ i ].mData = new float( v ); - } - break; + float v; + ::memcpy(&v, rhs.mValues[i].mData, sizeof(float)); + mValues[i].mData = new float(v); + } break; case AI_DOUBLE: { - double v; - ::memcpy( &v, rhs.mValues[ i ].mData, sizeof( double ) ); - mValues[ i ].mData = new double( v ); - } - break; + double v; + ::memcpy(&v, rhs.mValues[i].mData, sizeof(double)); + mValues[i].mData = new double(v); + } break; case AI_AISTRING: { - aiString v; - rhs.Get( mKeys[ i ], v ); - mValues[ i ].mData = new aiString( v ); - } - break; + aiString v; + rhs.Get(mKeys[i], v); + mValues[i].mData = new aiString(v); + } break; case AI_AIVECTOR3D: { - aiVector3D v; - rhs.Get( mKeys[ i ], v ); - mValues[ i ].mData = new aiVector3D( v ); - } - break; + aiVector3D v; + rhs.Get(mKeys[i], v); + mValues[i].mData = new aiVector3D(v); + } break; #ifndef SWIG case FORCE_32BIT: #endif default: break; } - } } @@ -206,33 +209,33 @@ struct aiMetadata { * @brief The destructor. */ ~aiMetadata() { - delete [] mKeys; + delete[] mKeys; mKeys = nullptr; if (mValues) { // Delete each metadata entry - for (unsigned i=0; i( data ); + delete static_cast(data); break; case AI_INT32: - delete static_cast< int32_t* >( data ); + delete static_cast(data); break; case AI_UINT64: - delete static_cast< uint64_t* >( data ); + delete static_cast(data); break; case AI_FLOAT: - delete static_cast< float* >( data ); + delete static_cast(data); break; case AI_DOUBLE: - delete static_cast< double* >( data ); + delete static_cast(data); break; case AI_AISTRING: - delete static_cast< aiString* >( data ); + delete static_cast(data); break; case AI_AIVECTOR3D: - delete static_cast< aiVector3D* >( data ); + delete static_cast(data); break; #ifndef SWIG case FORCE_32BIT: @@ -243,7 +246,7 @@ struct aiMetadata { } // Delete the metadata array - delete [] mValues; + delete[] mValues; mValues = nullptr; } } @@ -252,16 +255,15 @@ struct aiMetadata { * @brief Allocates property fields + keys. * @param numProperties Number of requested properties. */ - static inline - aiMetadata *Alloc( unsigned int numProperties ) { - if ( 0 == numProperties ) { + static inline aiMetadata *Alloc(unsigned int numProperties) { + if (0 == numProperties) { return nullptr; } aiMetadata *data = new aiMetadata; data->mNumProperties = numProperties; - data->mKeys = new aiString[ data->mNumProperties ](); - data->mValues = new aiMetadataEntry[ data->mNumProperties ](); + data->mKeys = new aiString[data->mNumProperties](); + data->mValues = new aiMetadataEntry[data->mNumProperties](); return data; } @@ -269,44 +271,40 @@ struct aiMetadata { /** * @brief Deallocates property fields + keys. */ - static inline - void Dealloc( aiMetadata *metadata ) { + static inline void Dealloc(aiMetadata *metadata) { delete metadata; } - template - inline - void Add(const std::string& key, const T& value) { - aiString* new_keys = new aiString[mNumProperties + 1]; - aiMetadataEntry* new_values = new aiMetadataEntry[mNumProperties + 1]; + template + inline void Add(const std::string &key, const T &value) { + aiString *new_keys = new aiString[mNumProperties + 1]; + aiMetadataEntry *new_values = new aiMetadataEntry[mNumProperties + 1]; - for(unsigned int i = 0; i < mNumProperties; ++i) - { - new_keys[i] = mKeys[i]; - new_values[i] = mValues[i]; - } + for (unsigned int i = 0; i < mNumProperties; ++i) { + new_keys[i] = mKeys[i]; + new_values[i] = mValues[i]; + } - delete[] mKeys; - delete[] mValues; + delete[] mKeys; + delete[] mValues; - mKeys = new_keys; - mValues = new_values; + mKeys = new_keys; + mValues = new_values; - mNumProperties++; + mNumProperties++; - Set(mNumProperties - 1, key, value); - } + Set(mNumProperties - 1, key, value); + } - template - inline - bool Set( unsigned index, const std::string& key, const T& value ) { + template + inline bool Set(unsigned index, const std::string &key, const T &value) { // In range assertion - if ( index >= mNumProperties ) { + if (index >= mNumProperties) { return false; } // Ensure that we have a valid key. - if ( key.empty() ) { + if (key.empty()) { return false; } @@ -321,73 +319,86 @@ struct aiMetadata { return true; } - template - inline - bool Get( unsigned index, T& value ) const { + template + inline bool Set( const std::string &key, const T &value ) { + if (key.empty()) { + return false; + } + + bool result = false; + for (unsigned int i = 0; i < mNumProperties; ++i) { + if (key == mKeys[i].C_Str()) { + Set(i, key, value); + result = true; + break; + } + } + + return result; + } + + template + inline bool Get(unsigned index, T &value) const { // In range assertion - if ( index >= mNumProperties ) { + if (index >= mNumProperties) { return false; } // Return false if the output data type does // not match the found value's data type - if ( GetAiType( value ) != mValues[ index ].mType ) { + if (GetAiType(value) != mValues[index].mType) { return false; } // Otherwise, output the found value and // return true - value = *static_cast(mValues[index].mData); + value = *static_cast(mValues[index].mData); return true; } - template - inline - bool Get( const aiString& key, T& value ) const { + template + inline bool Get(const aiString &key, T &value) const { // Search for the given key - for ( unsigned int i = 0; i < mNumProperties; ++i ) { - if ( mKeys[ i ] == key ) { - return Get( i, value ); + for (unsigned int i = 0; i < mNumProperties; ++i) { + if (mKeys[i] == key) { + return Get(i, value); } } return false; } - template - inline - bool Get( const std::string& key, T& value ) const { + template + inline bool Get(const std::string &key, T &value) const { return Get(aiString(key), value); } - /// Return metadata entry for analyzing it by user. - /// \param [in] pIndex - index of the entry. - /// \param [out] pKey - pointer to the key value. - /// \param [out] pEntry - pointer to the entry: type and value. - /// \return false - if pIndex is out of range, else - true. - inline - bool Get(size_t index, const aiString*& key, const aiMetadataEntry*& entry) const { - if ( index >= mNumProperties ) { + /// Return metadata entry for analyzing it by user. + /// \param [in] pIndex - index of the entry. + /// \param [out] pKey - pointer to the key value. + /// \param [out] pEntry - pointer to the entry: type and value. + /// \return false - if pIndex is out of range, else - true. + inline bool Get(size_t index, const aiString *&key, const aiMetadataEntry *&entry) const { + if (index >= mNumProperties) { return false; } - key = &mKeys[index]; - entry = &mValues[index]; + key = &mKeys[index]; + entry = &mValues[index]; - return true; - } + return true; + } /// Check whether there is a metadata entry for the given key. /// \param [in] Key - the key value value to check for. - inline - bool HasKey(const char* key) { - if ( nullptr == key ) { + inline bool HasKey(const char *key) { + if (nullptr == key) { return false; } - + // Search for the given key for (unsigned int i = 0; i < mNumProperties; ++i) { - if ( 0 == strncmp(mKeys[i].C_Str(), key, mKeys[i].length ) ) { + if (0 == strncmp(mKeys[i].C_Str(), key, mKeys[i].length)) { return true; } } @@ -395,7 +406,6 @@ struct aiMetadata { } #endif // __cplusplus - }; #endif // AI_METADATA_H_INC diff --git a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h index 125b3e585..e0169ee1a 100644 --- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h +++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h @@ -31,40 +31,40 @@ struct Texture { class Mesh { public: - std::vector vertices; - std::vector indices; - std::vector textures; - ID3D11Device *dev; + std::vector vertices_; + std::vector indices_; + std::vector textures_; + ID3D11Device *dev_; Mesh(ID3D11Device *dev, const std::vector& vertices, const std::vector& indices, const std::vector& textures) : - vertices(vertices), - indices(indices), - textures(textures), - dev(dev), - VertexBuffer(nullptr), - IndexBuffer(nullptr) { - this->setupMesh(this->dev); + vertices_(vertices), + indices_(indices), + textures_(textures), + dev_(dev), + VertexBuffer_(nullptr), + IndexBuffer_(nullptr) { + this->setupMesh(this->dev_); } void Draw(ID3D11DeviceContext *devcon) { UINT stride = sizeof(VERTEX); UINT offset = 0; - devcon->IASetVertexBuffers(0, 1, &VertexBuffer, &stride, &offset); - devcon->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0); + devcon->IASetVertexBuffers(0, 1, &VertexBuffer_, &stride, &offset); + devcon->IASetIndexBuffer(IndexBuffer_, DXGI_FORMAT_R32_UINT, 0); - devcon->PSSetShaderResources(0, 1, &textures[0].texture); + devcon->PSSetShaderResources(0, 1, &textures_[0].texture); - devcon->DrawIndexed(static_cast(indices.size()), 0, 0); + devcon->DrawIndexed(static_cast(indices_.size()), 0, 0); } void Close() { - SafeRelease(VertexBuffer); - SafeRelease(IndexBuffer); + SafeRelease(VertexBuffer_); + SafeRelease(IndexBuffer_); } private: // Render data - ID3D11Buffer *VertexBuffer, *IndexBuffer; + ID3D11Buffer *VertexBuffer_, *IndexBuffer_; // Functions // Initializes all the buffer objects/arrays @@ -73,15 +73,15 @@ private: D3D11_BUFFER_DESC vbd; vbd.Usage = D3D11_USAGE_IMMUTABLE; - vbd.ByteWidth = static_cast(sizeof(VERTEX) * vertices.size()); + vbd.ByteWidth = static_cast(sizeof(VERTEX) * vertices_.size()); vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER; vbd.CPUAccessFlags = 0; vbd.MiscFlags = 0; D3D11_SUBRESOURCE_DATA initData; - initData.pSysMem = &vertices[0]; + initData.pSysMem = &vertices_[0]; - hr = dev->CreateBuffer(&vbd, &initData, &VertexBuffer); + hr = dev->CreateBuffer(&vbd, &initData, &VertexBuffer_); if (FAILED(hr)) { Close(); throw std::runtime_error("Failed to create vertex buffer."); @@ -89,14 +89,14 @@ private: D3D11_BUFFER_DESC ibd; ibd.Usage = D3D11_USAGE_IMMUTABLE; - ibd.ByteWidth = static_cast(sizeof(UINT) * indices.size()); + ibd.ByteWidth = static_cast(sizeof(UINT) * indices_.size()); ibd.BindFlags = D3D11_BIND_INDEX_BUFFER; ibd.CPUAccessFlags = 0; ibd.MiscFlags = 0; - initData.pSysMem = &indices[0]; + initData.pSysMem = &indices_[0]; - hr = dev->CreateBuffer(&ibd, &initData, &IndexBuffer); + hr = dev->CreateBuffer(&ibd, &initData, &IndexBuffer_); if (FAILED(hr)) { Close(); throw std::runtime_error("Failed to create index buffer."); diff --git a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp index 806320144..c8f86bbec 100644 --- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp +++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp @@ -1,12 +1,12 @@ #include "ModelLoader.h" ModelLoader::ModelLoader() : - dev(nullptr), - devcon(nullptr), - meshes(), - directory(), - textures_loaded(), - hwnd(nullptr) { + dev_(nullptr), + devcon_(nullptr), + meshes_(), + directory_(), + textures_loaded_(), + hwnd_(nullptr) { // empty } @@ -25,11 +25,11 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc if (pScene == NULL) return false; - this->directory = filename.substr(0, filename.find_last_of("/\\")); + this->directory_ = filename.substr(0, filename.find_last_of("/\\")); - this->dev = dev; - this->devcon = devcon; - this->hwnd = hwnd; + this->dev_ = dev; + this->devcon_ = devcon; + this->hwnd_ = hwnd; processNode(pScene->mRootNode, pScene); @@ -37,8 +37,8 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc } void ModelLoader::Draw(ID3D11DeviceContext * devcon) { - for (int i = 0; i < meshes.size(); ++i ) { - meshes[i].Draw(devcon); + for (size_t i = 0; i < meshes_.size(); ++i ) { + meshes_[i].Draw(devcon); } } @@ -88,7 +88,7 @@ Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene) { textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end()); } - return Mesh(dev, vertices, indices, textures); + return Mesh(dev_, vertices, indices, textures); } std::vector ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, std::string typeName, const aiScene * scene) { @@ -98,9 +98,9 @@ std::vector ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextu mat->GetTexture(type, i, &str); // Check if texture was loaded before and if so, continue to next iteration: skip loading a new texture bool skip = false; - for (UINT j = 0; j < textures_loaded.size(); j++) { - if (std::strcmp(textures_loaded[j].path.c_str(), str.C_Str()) == 0) { - textures.push_back(textures_loaded[j]); + for (UINT j = 0; j < textures_loaded_.size(); j++) { + if (std::strcmp(textures_loaded_[j].path.c_str(), str.C_Str()) == 0) { + textures.push_back(textures_loaded_[j]); skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization) break; } @@ -113,34 +113,34 @@ std::vector ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextu texture.texture = getTextureFromModel(scene, textureindex); } else { std::string filename = std::string(str.C_Str()); - filename = directory + '/' + filename; + filename = directory_ + '/' + filename; std::wstring filenamews = std::wstring(filename.begin(), filename.end()); - hr = CreateWICTextureFromFile(dev, devcon, filenamews.c_str(), nullptr, &texture.texture); + hr = CreateWICTextureFromFile(dev_, devcon_, filenamews.c_str(), nullptr, &texture.texture); if (FAILED(hr)) - MessageBox(hwnd, "Texture couldn't be loaded", "Error!", MB_ICONERROR | MB_OK); + MessageBox(hwnd_, "Texture couldn't be loaded", "Error!", MB_ICONERROR | MB_OK); } texture.type = typeName; texture.path = str.C_Str(); textures.push_back(texture); - this->textures_loaded.push_back(texture); // Store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures. + this->textures_loaded_.push_back(texture); // Store it as texture loaded for entire model, to ensure we won't unnecesery load duplicate textures. } } return textures; } void ModelLoader::Close() { - for (auto& t : textures_loaded) + for (auto& t : textures_loaded_) t.Release(); - for (int i = 0; i < meshes.size(); i++) { - meshes[i].Close(); + for (size_t i = 0; i < meshes_.size(); i++) { + meshes_[i].Close(); } } void ModelLoader::processNode(aiNode * node, const aiScene * scene) { for (UINT i = 0; i < node->mNumMeshes; i++) { aiMesh* mesh = scene->mMeshes[node->mMeshes[i]]; - meshes.push_back(this->processMesh(mesh, scene)); + meshes_.push_back(this->processMesh(mesh, scene)); } for (UINT i = 0; i < node->mNumChildren; i++) { @@ -179,9 +179,9 @@ ID3D11ShaderResourceView * ModelLoader::getTextureFromModel(const aiScene * scen int* size = reinterpret_cast(&scene->mTextures[textureindex]->mWidth); - hr = CreateWICTextureFromMemory(dev, devcon, reinterpret_cast(scene->mTextures[textureindex]->pcData), *size, nullptr, &texture); + hr = CreateWICTextureFromMemory(dev_, devcon_, reinterpret_cast(scene->mTextures[textureindex]->pcData), *size, nullptr, &texture); if (FAILED(hr)) - MessageBox(hwnd, "Texture couldn't be created from memory!", "Error!", MB_ICONERROR | MB_OK); + MessageBox(hwnd_, "Texture couldn't be created from memory!", "Error!", MB_ICONERROR | MB_OK); return texture; } diff --git a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h index 18ad03fa0..9d3ed50b3 100644 --- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h +++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h @@ -25,12 +25,12 @@ public: void Close(); private: - ID3D11Device *dev; - ID3D11DeviceContext *devcon; - std::vector meshes; - std::string directory; - std::vector textures_loaded; - HWND hwnd; + ID3D11Device *dev_; + ID3D11DeviceContext *devcon_; + std::vector meshes_; + std::string directory_; + std::vector textures_loaded_; + HWND hwnd_; void processNode(aiNode* node, const aiScene* scene); Mesh processMesh(aiMesh* mesh, const aiScene* scene); diff --git a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp index 781fe89e5..1ef4a401f 100644 --- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp +++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp @@ -56,7 +56,7 @@ const char g_szClassName[] = "directxWindowClass"; static std::string g_ModelPath; UINT width, height; -HWND hwnd = nullptr; +HWND g_hwnd = nullptr; // ------------------------------------------------------------ // DirectX Variables @@ -120,8 +120,8 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) return 0; } -int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, - LPWSTR lpCmdLine, int nCmdShow) +int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/, + LPWSTR /*lpCmdLine*/, int nCmdShow) { int argc; LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc); @@ -182,7 +182,7 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, RECT wr = { 0,0, SCREEN_WIDTH, SCREEN_HEIGHT }; AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE); - hwnd = CreateWindowEx( + g_hwnd = CreateWindowEx( WS_EX_CLIENTEDGE, g_szClassName, " Simple Textured Directx11 Sample ", @@ -191,21 +191,21 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, NULL, NULL, hInstance, NULL ); - if (hwnd == NULL) + if (g_hwnd == NULL) { MessageBox(NULL, "Window Creation Failed!", "Error!", MB_ICONEXCLAMATION | MB_OK); return 0; } - ShowWindow(hwnd, nCmdShow); - UpdateWindow(hwnd); + ShowWindow(g_hwnd, nCmdShow); + UpdateWindow(g_hwnd); width = wr.right - wr.left; height = wr.bottom - wr.top; try { - InitD3D(hInstance, hwnd); + InitD3D(hInstance, g_hwnd); while (true) { @@ -225,17 +225,17 @@ int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, CleanD3D(); return static_cast(msg.wParam); } catch (const std::exception& e) { - MessageBox(hwnd, e.what(), TEXT("Error!"), MB_ICONERROR | MB_OK); + MessageBox(g_hwnd, e.what(), TEXT("Error!"), MB_ICONERROR | MB_OK); CleanD3D(); return EXIT_FAILURE; } catch (...) { - MessageBox(hwnd, TEXT("Caught an unknown exception."), TEXT("Error!"), MB_ICONERROR | MB_OK); + MessageBox(g_hwnd, TEXT("Caught an unknown exception."), TEXT("Error!"), MB_ICONERROR | MB_OK); CleanD3D(); return EXIT_FAILURE; } } -void InitD3D(HINSTANCE hinstance, HWND hWnd) +void InitD3D(HINSTANCE /*hinstance*/, HWND hWnd) { HRESULT hr; @@ -362,7 +362,7 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd) } // Note this tutorial doesn't handle full-screen swapchains so we block the ALT+ENTER shortcut - dxgiFactory->MakeWindowAssociation(hwnd, DXGI_MWA_NO_ALT_ENTER); + dxgiFactory->MakeWindowAssociation(g_hwnd, DXGI_MWA_NO_ALT_ENTER); dxgiFactory->Release(); @@ -564,7 +564,7 @@ void InitGraphics() m_View = XMMatrixLookAtLH(Eye, At, Up); ourModel = new ModelLoader; - if (!ourModel->Load(hwnd, dev, devcon, g_ModelPath)) + if (!ourModel->Load(g_hwnd, dev, devcon, g_ModelPath)) Throwanerror("Model couldn't be loaded"); } diff --git a/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp b/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp index 452c0715c..806da8f8a 100644 --- a/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp +++ b/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp @@ -18,8 +18,10 @@ #include #include +#pragma warning(disable: 4100) // Disable warning 'unreferenced formal parameter' #define STB_IMAGE_IMPLEMENTATION #include "contrib/stb_image/stb_image.h" +#pragma warning(default: 4100) // Enable warning 'unreferenced formal parameter' #include @@ -38,10 +40,10 @@ // The default hard-coded path. Can be overridden by supplying a path through the command line. static std::string modelpath = "../../test/models/OBJ/spider.obj"; -HGLRC hRC=NULL; // Permanent Rendering Context -HDC hDC=NULL; // Private GDI Device Context -HWND hWnd=NULL; // Holds Window Handle -HINSTANCE hInstance; // Holds The Instance Of The Application +HGLRC hRC=nullptr; // Permanent Rendering Context +HDC hDC=nullptr; // Private GDI Device Context +HWND g_hWnd=nullptr; // Holds Window Handle +HINSTANCE g_hInstance=nullptr; // Holds The Instance Of The Application bool keys[256]; // Array used for Keyboard Routine; bool active=TRUE; // Window Active Flag Set To TRUE by Default @@ -64,7 +66,7 @@ GLfloat LightPosition[]= { 0.0f, 0.0f, 15.0f, 1.0f }; // the global Assimp scene object -const aiScene* scene = NULL; +const aiScene* g_scene = nullptr; GLuint scene_list = 0; aiVector3D scene_min, scene_max, scene_center; @@ -122,15 +124,15 @@ bool Import3DFromFile( const std::string& pFile) } else { - MessageBox(NULL, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); + MessageBox(nullptr, UTFConverter("Couldn't open file: " + pFile).c_wstr() , TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); logInfo( importer.GetErrorString()); return false; } - scene = importer.ReadFile( pFile, aiProcessPreset_TargetRealtime_Quality); + g_scene = importer.ReadFile(pFile, aiProcessPreset_TargetRealtime_Quality); // If the import failed, report it - if( !scene) + if(!g_scene) { logInfo( importer.GetErrorString()); return false; @@ -179,7 +181,7 @@ void freeTextureIds() if (textureIds) { delete[] textureIds; - textureIds = NULL; + textureIds = nullptr; } } @@ -215,7 +217,7 @@ int LoadGLTextures(const aiScene* scene) while (texFound == AI_SUCCESS) { texFound = scene->mMaterials[m]->GetTexture(aiTextureType_DIFFUSE, texIndex, &path); - textureIdMap[path.data] = NULL; //fill map with textures, pointers still NULL yet + textureIdMap[path.data] = nullptr; //fill map with textures, pointers still NULL yet texIndex++; } } @@ -283,7 +285,7 @@ int LoadGLTextures(const aiScene* scene) else { /* Error occurred */ - MessageBox(NULL, UTFConverter("Couldn't load Image: " + fileloc).c_wstr(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); + MessageBox(nullptr, UTFConverter("Couldn't load Image: " + fileloc).c_wstr(), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); } } // Because we have already copied image data into texture data we can release memory used by image. @@ -299,7 +301,7 @@ int LoadGLTextures(const aiScene* scene) // All Setup For OpenGL goes here int InitGL() { - if (!LoadGLTextures(scene)) + if (!LoadGLTextures(g_scene)) { return FALSE; } @@ -440,12 +442,12 @@ void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float // draw all meshes assigned to this node for (; n < nd->mNumMeshes; ++n) { - const struct aiMesh* mesh = scene->mMeshes[nd->mMeshes[n]]; + const struct aiMesh* mesh = sc->mMeshes[nd->mMeshes[n]]; apply_material(sc->mMaterials[mesh->mMaterialIndex]); - if(mesh->mNormals == NULL) + if(mesh->mNormals == nullptr) { glDisable(GL_LIGHTING); } @@ -454,7 +456,7 @@ void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float glEnable(GL_LIGHTING); } - if(mesh->mColors[0] != NULL) + if(mesh->mColors[0] != nullptr) { glEnable(GL_COLOR_MATERIAL); } @@ -480,9 +482,9 @@ void recursive_render (const struct aiScene *sc, const struct aiNode* nd, float for(i = 0; i < face->mNumIndices; i++) // go through all vertices in face { int vertexIndex = face->mIndices[i]; // get group index for current index - if(mesh->mColors[0] != NULL) + if(mesh->mColors[0] != nullptr) Color4f(&mesh->mColors[0][vertexIndex]); - if(mesh->mNormals != NULL) + if(mesh->mNormals != nullptr) if(mesh->HasTextureCoords(0)) //HasTextureCoords(texture_coordinates_set) { @@ -527,7 +529,7 @@ int DrawGLScene() //Here's where we do all the drawing glRotatef(yrot, 0.0f, 1.0f, 0.0f); glRotatef(zrot, 0.0f, 0.0f, 1.0f); - drawAiScene(scene); + drawAiScene(g_scene); //xrot+=0.3f; yrot+=0.2f; @@ -541,50 +543,50 @@ void KillGLWindow() // Properly Kill The Window { if (fullscreen) // Are We In Fullscreen Mode? { - ChangeDisplaySettings(NULL, 0); // If So Switch Back To The Desktop + ChangeDisplaySettings(nullptr, 0); // If So Switch Back To The Desktop ShowCursor(TRUE); // Show Mouse Pointer } if (hRC) // Do We Have A Rendering Context? { - if (!wglMakeCurrent(NULL, NULL)) // Are We Able To Release The DC And RC Contexts? + if (!wglMakeCurrent(nullptr, nullptr)) // Are We Able To Release The DC And RC Contexts? { - MessageBox(NULL, TEXT("Release Of DC And RC Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); + MessageBox(nullptr, TEXT("Release Of DC And RC Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); } if (!wglDeleteContext(hRC)) // Are We Able To Delete The RC? { - MessageBox(NULL, TEXT("Release Rendering Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); + MessageBox(nullptr, TEXT("Release Rendering Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); } - hRC = NULL; + hRC = nullptr; } if (hDC) { - if (!ReleaseDC(hWnd, hDC)) // Are We able to Release The DC? - MessageBox(NULL, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); - hDC = NULL; + if (!ReleaseDC(g_hWnd, hDC)) // Are We able to Release The DC? + MessageBox(nullptr, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); + hDC = nullptr; } - if (hWnd) + if (g_hWnd) { - if (!DestroyWindow(hWnd)) // Are We Able To Destroy The Window - MessageBox(NULL, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); - hWnd = NULL; + if (!DestroyWindow(g_hWnd)) // Are We Able To Destroy The Window + MessageBox(nullptr, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); + g_hWnd = nullptr; } - if (hInstance) + if (g_hInstance) { - if (!UnregisterClass(TEXT("OpenGL"), hInstance)) // Are We Able To Unregister Class - MessageBox(NULL, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); - hInstance = NULL; + if (!UnregisterClass(TEXT("OpenGL"), g_hInstance)) // Are We Able To Unregister Class + MessageBox(nullptr, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION); + g_hInstance = nullptr; } } GLboolean abortGLInit(const char* abortMessage) { KillGLWindow(); // Reset Display - MessageBox(NULL, UTFConverter(abortMessage).c_wstr(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION); + MessageBox(nullptr, UTFConverter(abortMessage).c_wstr(), TEXT("ERROR"), MB_OK|MB_ICONEXCLAMATION); return FALSE; // quit and return False } @@ -602,21 +604,21 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful fullscreen = fullscreenflag; - hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window + g_hInstance = GetModuleHandle(nullptr); // Grab An Instance For Our Window wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Move, And Own DC For Window wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc handles Messages wc.cbClsExtra = 0; // No Extra Window Data wc.cbWndExtra = 0; // No Extra Window Data - wc.hInstance = hInstance; - wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon - wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load the default arrow - wc.hbrBackground= NULL; // No Background required for OpenGL - wc.lpszMenuName = NULL; // No Menu + wc.hInstance = g_hInstance; + wc.hIcon = LoadIcon(nullptr, IDI_WINLOGO); // Load The Default Icon + wc.hCursor = LoadCursor(nullptr, IDC_ARROW); // Load the default arrow + wc.hbrBackground= nullptr; // No Background required for OpenGL + wc.lpszMenuName = nullptr; // No Menu wc.lpszClassName= TEXT("OpenGL"); // Class Name if (!RegisterClass(&wc)) { - MessageBox(NULL, TEXT("Failed to register the window class"), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); + MessageBox(nullptr, TEXT("Failed to register the window class"), TEXT("ERROR"), MB_OK | MB_ICONEXCLAMATION); return FALSE; //exit and return false } @@ -634,14 +636,14 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful if (ChangeDisplaySettings(&dmScreenSettings, CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) { // If The Mode Fails, Offer Two Options. Quit Or Run In A Window. - if (MessageBox(NULL,TEXT("The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?"),TEXT("NeHe GL"),MB_YESNO|MB_ICONEXCLAMATION)==IDYES) + if (MessageBox(nullptr,TEXT("The Requested Fullscreen Mode Is Not Supported By\nYour Video Card. Use Windowed Mode Instead?"),TEXT("NeHe GL"),MB_YESNO|MB_ICONEXCLAMATION)==IDYES) { fullscreen = FALSE; // Select Windowed Mode (Fullscreen = FALSE) } else { //Popup Messagebox: Closing - MessageBox(NULL, TEXT("Program will close now."), TEXT("ERROR"), MB_OK|MB_ICONSTOP); + MessageBox(nullptr, TEXT("Program will close now."), TEXT("ERROR"), MB_OK|MB_ICONSTOP); return FALSE; //exit, return false } } @@ -661,7 +663,7 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful AdjustWindowRectEx(&WindowRect, dwStyle, FALSE, dwExStyle); // Adjust Window To True Requestes Size - if (!(hWnd=CreateWindowEx( dwExStyle, // Extended Style For The Window + if (nullptr == (g_hWnd=CreateWindowEx(dwExStyle, // Extended Style For The Window TEXT("OpenGL"), // Class Name UTFConverter(title).c_wstr(), // Window Title WS_CLIPSIBLINGS | // Required Window Style @@ -670,10 +672,10 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful 0, 0, // Window Position WindowRect.right-WindowRect.left, // Calc adjusted Window Width WindowRect.bottom-WindowRect.top, // Calc adjustes Window Height - NULL, // No Parent Window - NULL, // No Menu - hInstance, // Instance - NULL ))) // Don't pass anything To WM_CREATE + nullptr, // No Parent Window + nullptr, // No Menu + g_hInstance, // Instance + nullptr ))) // Don't pass anything To WM_CREATE { abortGLInit("Window Creation Error."); return FALSE; @@ -701,13 +703,13 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful 0, 0, 0 // Layer Masks Ignored }; - if (!(hDC=GetDC(hWnd))) // Did we get the Device Context? + if (nullptr == (hDC=GetDC(g_hWnd))) // Did we get the Device Context? { abortGLInit("Can't Create A GL Device Context."); return FALSE; } - if (!(PixelFormat=ChoosePixelFormat(hDC, &pfd))) // Did We Find a matching pixel Format? + if (0 == (PixelFormat=ChoosePixelFormat(hDC, &pfd))) // Did We Find a matching pixel Format? { abortGLInit("Can't Find Suitable PixelFormat"); return FALSE; @@ -719,7 +721,7 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful return FALSE; } - if (!(hRC=wglCreateContext(hDC))) + if (nullptr == (hRC=wglCreateContext(hDC))) { abortGLInit("Can't Create A GL Rendering Context."); return FALSE; @@ -733,9 +735,9 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful //// *** everything okay *** - ShowWindow(hWnd, SW_SHOW); // Show The Window - SetForegroundWindow(hWnd); // Slightly Higher Prio - SetFocus(hWnd); // Sets Keyboard Focus To The Window + ShowWindow(g_hWnd, SW_SHOW); // Show The Window + SetForegroundWindow(g_hWnd); // Slightly Higher Prio + SetFocus(g_hWnd); // Sets Keyboard Focus To The Window ReSizeGLScene(width, height); // Set Up Our Perspective GL Screen if (!InitGL()) @@ -753,7 +755,7 @@ void cleanup() destroyAILogger(); - if (hWnd) + if (g_hWnd) KillGLWindow(); }; @@ -818,12 +820,12 @@ LRESULT CALLBACK WndProc(HWND hWnd, // Handles for this Window return DefWindowProc(hWnd, uMsg, wParam, lParam); } -int WINAPI WinMain( HINSTANCE hInstance, // The instance - HINSTANCE hPrevInstance, // Previous instance - LPSTR lpCmdLine, // Command Line Parameters - int nShowCmd ) // Window Show State +int WINAPI WinMain( HINSTANCE /*hInstance*/, // The instance + HINSTANCE /*hPrevInstance*/, // Previous instance + LPSTR /*lpCmdLine*/, // Command Line Parameters + int /*nShowCmd*/ ) // Window Show State { - MSG msg; + MSG msg = {}; BOOL done=FALSE; createAILogger(); @@ -832,7 +834,7 @@ int WINAPI WinMain( HINSTANCE hInstance, // The instance // Check the command line for an override file path. int argc; LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc); - if (argv != NULL && argc > 1) + if (argv != nullptr && argc > 1) { std::wstring modelpathW(argv[1]); modelpath = UTFConverter(modelpathW).str(); @@ -846,7 +848,7 @@ int WINAPI WinMain( HINSTANCE hInstance, // The instance logInfo("=============== Post Import ===================="); - if (MessageBox(NULL, TEXT("Would You Like To Run In Fullscreen Mode?"), TEXT("Start Fullscreen?"), MB_YESNO|MB_ICONEXCLAMATION)==IDNO) + if (MessageBox(nullptr, TEXT("Would You Like To Run In Fullscreen Mode?"), TEXT("Start Fullscreen?"), MB_YESNO|MB_ICONEXCLAMATION)==IDNO) { fullscreen=FALSE; } @@ -859,7 +861,7 @@ int WINAPI WinMain( HINSTANCE hInstance, // The instance while(!done) // Game Loop { - if (PeekMessage(&msg, NULL, 0,0, PM_REMOVE)) + if (PeekMessage(&msg, nullptr, 0,0, PM_REMOVE)) { if (msg.message==WM_QUIT) { diff --git a/test/unit/utFBXImporterExporter.cpp b/test/unit/utFBXImporterExporter.cpp index 30a26d99d..88a3e067e 100644 --- a/test/unit/utFBXImporterExporter.cpp +++ b/test/unit/utFBXImporterExporter.cpp @@ -213,6 +213,10 @@ TEST_F(utFBXImporterExporter, importUnitScaleFactor) { double factor(0.0); scene->mMetaData->Get("UnitScaleFactor", factor); EXPECT_DOUBLE_EQ(500.0, factor); + + scene->mMetaData->Set("UnitScaleFactor", factor * 2); + scene->mMetaData->Get("UnitScaleFactor", factor); + EXPECT_DOUBLE_EQ(1000.0, factor); } TEST_F(utFBXImporterExporter, importEmbeddedAsciiTest) { diff --git a/tools/assimp_view/Background.cpp b/tools/assimp_view/Background.cpp index e5f4e2b96..d1db3b60a 100644 --- a/tools/assimp_view/Background.cpp +++ b/tools/assimp_view/Background.cpp @@ -101,7 +101,7 @@ void CBackgroundPainter::SetColor (D3DCOLOR p_clrNew) if (pcTexture) { pcTexture->Release(); - pcTexture = NULL; + pcTexture = nullptr; } } //------------------------------------------------------------------------------- @@ -135,7 +135,7 @@ void CBackgroundPainter::SetCubeMapBG (const char* p_szPath) if (pcTexture) { pcTexture->Release(); - pcTexture = NULL; + pcTexture = nullptr; if(TEXTURE_CUBE ==eMode)bHad = true; } @@ -199,7 +199,7 @@ void CBackgroundPainter::SetTextureBG (const char* p_szPath) if (pcTexture) { pcTexture->Release(); - pcTexture = NULL; + pcTexture = nullptr; } eMode = TEXTURE_2D; @@ -223,12 +223,12 @@ void CBackgroundPainter::OnPreRender() // the color buffer ) if (g_sOptions.eDrawMode == RenderOptions::WIREFRAME) { - g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET, + g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER | D3DCLEAR_TARGET, D3DCOLOR_ARGB(0xff,100,100,100),1.0f,0); } else { - g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER,0,1.0f,0); + g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER,0,1.0f,0); } if (TEXTURE_2D == eMode) @@ -293,7 +293,7 @@ void CBackgroundPainter::OnPreRender() return; } // clear both the render target and the z-buffer - g_piDevice->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, + g_piDevice->Clear(0,nullptr,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, clrColor,1.0f,0); } //------------------------------------------------------------------------------- @@ -342,12 +342,12 @@ void CBackgroundPainter::ReleaseNativeResource() if ( piSkyBoxEffect) { piSkyBoxEffect->Release(); - piSkyBoxEffect = NULL; + piSkyBoxEffect = nullptr; } if (pcTexture) { pcTexture->Release(); - pcTexture = NULL; + pcTexture = nullptr; } } //------------------------------------------------------------------------------- @@ -377,8 +377,8 @@ void CBackgroundPainter::RecreateNativeResource() D3DX_DEFAULT, D3DX_DEFAULT, 0, - NULL, - NULL, + nullptr, + nullptr, (IDirect3DCubeTexture9**)&pcTexture))) { const char* szEnd = strrchr(szPath.c_str(),'\\'); @@ -411,8 +411,8 @@ void CBackgroundPainter::RecreateNativeResource() D3DX_DEFAULT, D3DX_DEFAULT, 0, - NULL, - NULL, + nullptr, + nullptr, (IDirect3DTexture9**)&pcTexture))) { const char* szEnd = strrchr(szPath.c_str(),'\\'); @@ -433,15 +433,15 @@ void CBackgroundPainter::RecreateNativeResource() } if (!piSkyBoxEffect) { - ID3DXBuffer* piBuffer = NULL; + ID3DXBuffer* piBuffer = nullptr; if(FAILED( D3DXCreateEffect( g_piDevice, g_szSkyboxShader.c_str(), (UINT)g_szSkyboxShader.length(), - NULL, - NULL, + nullptr, + nullptr, AI_SHADER_COMPILE_FLAGS, - NULL, + nullptr, &piSkyBoxEffect,&piBuffer))) { // failed to compile the shader diff --git a/tools/assimp_view/Display.cpp b/tools/assimp_view/Display.cpp index f66f6bc92..9fa157c41 100644 --- a/tools/assimp_view/Display.cpp +++ b/tools/assimp_view/Display.cpp @@ -158,8 +158,8 @@ int CDisplay::AddNodeToDisplayList( aiNode* pcNode, HTREEITEM hRoot) { - ai_assert(NULL != pcNode); - ai_assert(NULL != hRoot); + ai_assert(nullptr != pcNode); + ai_assert(nullptr != hRoot); char chTemp[MAXLEN]; @@ -269,13 +269,13 @@ int CDisplay::AddMeshToDisplayList(unsigned int iIndex, HTREEITEM hRoot) // Replace the currently selected texture by another one int CDisplay::ReplaceCurrentTexture(const char* szPath) { - ai_assert(NULL != szPath); + ai_assert(nullptr != szPath); // well ... try to load it - IDirect3DTexture9* piTexture = NULL; + IDirect3DTexture9* piTexture = nullptr; aiString szString; strcpy(szString.data,szPath); - szString.length = strlen(szPath); + szString.length = static_cast(strlen(szPath)); CMaterialManager::Instance().LoadTexture(&piTexture,&szString); if (!piTexture) { @@ -301,8 +301,8 @@ int CDisplay::ReplaceCurrentTexture(const char* szPath) continue; AssetHelper::MeshHelper* pcMesh = g_pcAsset->apcMeshes[i]; - IDirect3DTexture9** tex = NULL; - const char* tex_string = NULL; + IDirect3DTexture9** tex = nullptr; + const char* tex_string = nullptr; switch (this->m_pcCurrentTexture->iType) { @@ -378,7 +378,7 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType, aiTextureOp eTextureOp /*= aiTextureOp_Multiply*/, unsigned int iMesh /*= 0*/) { - ai_assert(NULL != szPath); + ai_assert(nullptr != szPath); char chTemp[512]; char chTempEmb[256]; @@ -388,8 +388,8 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType, { if ('*' == *szPath->data) { - int iIndex = atoi(szPath->data+1); - ai_snprintf(chTempEmb,256,"Embedded #%i",iIndex); + int iIndex2 = atoi(szPath->data+1); + ai_snprintf(chTempEmb,256,"Embedded #%i",iIndex2); sz = chTempEmb; } else @@ -436,15 +436,15 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType, szType = "Lightmap"; break; case aiTextureType_DISPLACEMENT: - piTexture = NULL; + piTexture = nullptr; szType = "Displacement"; break; case aiTextureType_REFLECTION: - piTexture = NULL; + piTexture = nullptr; szType = "Reflection"; break; case aiTextureType_UNKNOWN: - piTexture = NULL; + piTexture = nullptr; szType = "Unknown"; break; default: // opacity + opacity | mask @@ -521,7 +521,7 @@ int CDisplay::AddTextureToDisplayList(unsigned int iType, int CDisplay::AddMaterialToDisplayList(HTREEITEM hRoot, unsigned int iIndex) { - ai_assert(NULL != hRoot); + ai_assert(nullptr != hRoot); aiMaterial* pcMat = g_pcAsset->pcScene->mMaterials[iIndex]; @@ -583,7 +583,7 @@ int CDisplay::AddMaterialToDisplayList(HTREEITEM hRoot, while (true) { if (AI_SUCCESS != aiGetMaterialTexture(pcMat,(aiTextureType)i,iNum, - &szPath,NULL, &iUV,&fBlend,&eOp)) + &szPath,nullptr, &iUV,&fBlend,&eOp)) { break; } @@ -658,23 +658,23 @@ int CDisplay::LoadImageList(void) // Load the bitmaps and add them to the image lists. HBITMAP hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BFX)); - m_aiImageList[AI_VIEW_IMGLIST_MATERIAL] = ImageList_Add(hIml, hBmp, NULL); + m_aiImageList[AI_VIEW_IMGLIST_MATERIAL] = ImageList_Add(hIml, hBmp, nullptr); DeleteObject(hBmp); hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BNODE)); - m_aiImageList[AI_VIEW_IMGLIST_NODE] = ImageList_Add(hIml, hBmp, NULL); + m_aiImageList[AI_VIEW_IMGLIST_NODE] = ImageList_Add(hIml, hBmp, nullptr); DeleteObject(hBmp); hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BTX)); - m_aiImageList[AI_VIEW_IMGLIST_TEXTURE] = ImageList_Add(hIml, hBmp, NULL); + m_aiImageList[AI_VIEW_IMGLIST_TEXTURE] = ImageList_Add(hIml, hBmp, nullptr); DeleteObject(hBmp); hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BTXI)); - m_aiImageList[AI_VIEW_IMGLIST_TEXTURE_INVALID] = ImageList_Add(hIml, hBmp, NULL); + m_aiImageList[AI_VIEW_IMGLIST_TEXTURE_INVALID] = ImageList_Add(hIml, hBmp, nullptr); DeleteObject(hBmp); hBmp = LoadBitmap(g_hInstance, MAKEINTRESOURCE(IDB_BROOT)); - m_aiImageList[AI_VIEW_IMGLIST_MODEL] = ImageList_Add(hIml, hBmp, NULL); + m_aiImageList[AI_VIEW_IMGLIST_MODEL] = ImageList_Add(hIml, hBmp, nullptr); DeleteObject(hBmp); // Associate the image list with the tree. @@ -778,7 +778,7 @@ int CDisplay::OnRender() // present the back-buffer g_piDevice->EndScene(); - g_piDevice->Present(NULL,NULL,NULL,NULL); + g_piDevice->Present(nullptr,nullptr,nullptr,nullptr); // don't remove this, problems on some older machines (AMD timing bug) Sleep(10); @@ -788,9 +788,9 @@ int CDisplay::OnRender() // Update UI void UpdateColorFieldsInUI() { - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),NULL,TRUE); - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE); - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),nullptr,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR1)); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR2)); @@ -859,7 +859,7 @@ int CDisplay::Reset(void) m_asNodes.clear(); m_asMeshes.clear(); - m_hRoot = NULL; + m_hRoot = nullptr; return OnSetupNormalView(); } @@ -896,9 +896,9 @@ int CDisplay::OnSetupNormalView() SetViewMode(VIEWMODE_FULL); // for debugging - m_pcCurrentMaterial = NULL; - m_pcCurrentTexture = NULL; - m_pcCurrentNode = NULL; + m_pcCurrentMaterial = nullptr; + m_pcCurrentTexture = nullptr; + m_pcCurrentNode = nullptr; // redraw the color fields in the UI --- their purpose has possibly changed UpdateColorFieldsInUI(); @@ -908,7 +908,7 @@ int CDisplay::OnSetupNormalView() //------------------------------------------------------------------------------- int CDisplay::OnSetupNodeView(NodeInfo* pcNew) { - ai_assert(NULL != pcNew); + ai_assert(nullptr != pcNew); if (m_pcCurrentNode == pcNew)return 2; @@ -955,7 +955,7 @@ int CDisplay::OnSetupNodeView(NodeInfo* pcNew) //------------------------------------------------------------------------------- int CDisplay::OnSetupMaterialView(MaterialInfo* pcNew) { - ai_assert(NULL != pcNew); + ai_assert(nullptr != pcNew); if (m_pcCurrentMaterial == pcNew)return 2; @@ -973,7 +973,7 @@ int CDisplay::OnSetupMaterialView(MaterialInfo* pcNew) //------------------------------------------------------------------------------- int CDisplay::OnSetupTextureView(TextureInfo* pcNew) { - ai_assert(NULL != pcNew); + ai_assert(nullptr != pcNew); if (this->m_pcCurrentTexture == pcNew)return 2; @@ -1099,7 +1099,7 @@ int CDisplay::OnSetup(HTREEITEM p_hTreeItem) MaterialInfo* pcNew3; }; - pcNew = NULL; + pcNew = nullptr; for (std::vector::iterator i = m_asTextures.begin();i != m_asTextures.end();++i){ if (p_hTreeItem == (*i).hTreeItem) { pcNew = &(*i); @@ -1136,12 +1136,12 @@ int CDisplay::OnSetup(HTREEITEM p_hTreeItem) //------------------------------------------------------------------------------- int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem) { - ai_assert(NULL != hItem); + ai_assert(nullptr != hItem); - HMENU hDisplay = NULL; + HMENU hDisplay = nullptr; // search in our list for the item - TextureInfo* pcNew = NULL; + TextureInfo* pcNew = nullptr; for (std::vector::iterator i = m_asTextures.begin(); i != m_asTextures.end();++i) @@ -1158,7 +1158,7 @@ int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem) } // search in the material list for the item - MaterialInfo* pcNew2 = NULL; + MaterialInfo* pcNew2 = nullptr; for (std::vector::iterator i = m_asMaterials.begin(); i != m_asMaterials.end();++i) @@ -1173,7 +1173,7 @@ int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem) HMENU hMenu = LoadMenu(g_hInstance,MAKEINTRESOURCE(IDR_MATPOPUP)); hDisplay = GetSubMenu(hMenu,0); } - if (NULL != hDisplay) + if (nullptr != hDisplay) { // select this entry (this should all OnSetup()) TreeView_Select(GetDlgItem(g_hDlg,IDC_TREE1),hItem,TVGN_CARET); @@ -1185,7 +1185,7 @@ int CDisplay::ShowTreeViewContextMenu(HTREEITEM hItem) POINT sPoint; GetCursorPos(&sPoint); TrackPopupMenu(hDisplay, TPM_LEFTALIGN, sPoint.x, sPoint.y, 0, - g_hDlg,NULL); + g_hDlg,nullptr); } return 1; } @@ -1260,8 +1260,8 @@ int CDisplay::HandleTreeViewPopup(WPARAM wParam,LPARAM lParam) clamp(clrOld.g * 255.0f), clamp(clrOld.b * 255.0f)); clr.lpCustColors = g_aclCustomColors; - clr.lpfnHook = NULL; - clr.lpTemplateName = NULL; + clr.lpfnHook = nullptr; + clr.lpTemplateName = nullptr; clr.lCustData = 0; ChooseColor(&clr); @@ -1308,7 +1308,7 @@ int CALLBACK TreeViewCompareFunc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSo return 0; } //------------------------------------------------------------------------------- -int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) +int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM /*lParam*/) { char szFileName[MAX_PATH]; DWORD dwTemp = MAX_PATH; @@ -1318,7 +1318,7 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) case ID_HEY_REPLACE: { // get a path to a new texture - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ReplaceTextureSrc",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ReplaceTextureSrc",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: @@ -1335,13 +1335,13 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) } OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), + g_hDlg,GetModuleHandle(nullptr), "Textures\0*.png;*.dds;*.tga;*.bmp;*.tif;*.ppm;*.ppx;*.jpg;*.jpeg;*.exr\0*.*\0", - NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Replace this texture", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ".jpg", 0, NULL, NULL + 0, 1, ".jpg", 0, nullptr, nullptr }; if(GetOpenFileName(&sFilename1) == 0) return 0; @@ -1353,7 +1353,7 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) case ID_HEY_EXPORT: { - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureExportDest",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureExportDest",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: @@ -1370,12 +1370,12 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) } OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), - "Textures\0*.png;*.dds;*.bmp;*.tif;*.pfm;*.jpg;*.jpeg;*.hdr\0*.*\0", NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + g_hDlg,GetModuleHandle(nullptr), + "Textures\0*.png;*.dds;*.bmp;*.tif;*.pfm;*.jpg;*.jpeg;*.hdr\0*.*\0", nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Export texture to file", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ".png", 0, NULL, NULL + 0, 1, ".png", 0, nullptr, nullptr }; if(GetSaveFileName(&sFilename1) == 0) return 0; @@ -1397,9 +1397,9 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) } // get a pointer to the first surface of the current texture - IDirect3DSurface9* pi = NULL; + IDirect3DSurface9* pi = nullptr; (*this->m_pcCurrentTexture->piTexture)->GetSurfaceLevel(0,&pi); - if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,eFormat,pi,NULL,NULL))) + if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,eFormat,pi,nullptr,nullptr))) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to export texture", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); @@ -1495,7 +1495,7 @@ int CDisplay::HandleTreeViewPopup2(WPARAM wParam,LPARAM lParam) // Setup stereo view int CDisplay::SetupStereoView() { - if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode) + if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode) { // enable the RED, GREEN and ALPHA channels g_piDevice->SetRenderState(D3DRS_COLORWRITEENABLE, @@ -1513,7 +1513,7 @@ int CDisplay::SetupStereoView() int CDisplay::RenderStereoView(const aiMatrix4x4& m) { // and rerender the scene - if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode) + if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode) { // enable the BLUE, GREEN and ALPHA channels g_piDevice->SetRenderState(D3DRS_COLORWRITEENABLE, @@ -1522,7 +1522,7 @@ int CDisplay::RenderStereoView(const aiMatrix4x4& m) D3DCOLORWRITEENABLE_BLUE); // clear the z-buffer - g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER,0,1.0f,0); + g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER,0,1.0f,0); // move the camera a little bit to the right g_sCamera.vPos += g_sCamera.vRight * 0.06f; @@ -1751,7 +1751,7 @@ int CDisplay::RenderFullScene() // draw all opaque objects in the scene aiMatrix4x4 m; - if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode) + if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode) { HandleInput(); m = g_mWorld * g_mWorldRotate; @@ -1766,7 +1766,7 @@ int CDisplay::RenderFullScene() CBackgroundPainter::Instance().OnPostRender(); // draw all non-opaque objects in the scene - if (NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode) + if (nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode) { // disable the z-buffer if (!g_sOptions.bNoAlphaBlending) { @@ -1784,7 +1784,7 @@ int CDisplay::RenderFullScene() RenderStereoView(m); // render the skeleton if necessary - if (g_sOptions.bSkeleton && NULL != g_pcAsset && NULL != g_pcAsset->pcScene->mRootNode) { + if (g_sOptions.bSkeleton && nullptr != g_pcAsset && nullptr != g_pcAsset->pcScene->mRootNode) { // disable the z-buffer g_piDevice->SetRenderState(D3DRS_ZWRITEENABLE,FALSE); @@ -1795,11 +1795,11 @@ int CDisplay::RenderFullScene() g_piDevice->SetVertexDeclaration( gDefaultVertexDecl); // this is very similar to the code in SetupMaterial() ID3DXEffect* piEnd = g_piNormalsEffect; - aiMatrix4x4 pcProj = m * mViewProjection; + aiMatrix4x4 pcProj2 = m * mViewProjection; D3DXVECTOR4 vVector(1.f,0.f,0.f,1.f); piEnd->SetVector("OUTPUT_COLOR",&vVector); - piEnd->SetMatrix("WorldViewProjection", (const D3DXMATRIX*)&pcProj); + piEnd->SetMatrix("WorldViewProjection", (const D3DXMATRIX*)&pcProj2); UINT dwPasses = 0; piEnd->Begin(&dwPasses,0); @@ -2098,14 +2098,14 @@ int CDisplay::RenderPatternBG() { // seems we have not yet compiled this shader. // and NOW is the best time to do that ... - ID3DXBuffer* piBuffer = NULL; + ID3DXBuffer* piBuffer = nullptr; if(FAILED( D3DXCreateEffect(g_piDevice, g_szCheckerBackgroundShader.c_str(), (UINT)g_szCheckerBackgroundShader.length(), - NULL, - NULL, + nullptr, + nullptr, D3DXSHADER_USE_LEGACY_D3DX9_31_DLL, - NULL, + nullptr, &g_piPatternEffect,&piBuffer))) { if( piBuffer) @@ -2118,7 +2118,7 @@ int CDisplay::RenderPatternBG() if( piBuffer) { piBuffer->Release(); - piBuffer = NULL; + piBuffer = nullptr; } } else @@ -2126,14 +2126,14 @@ int CDisplay::RenderPatternBG() // clear the color buffer in magenta // (hopefully this is ugly enough that every ps_2_0 cards owner // runs to the next shop to buy himself a new card ...) - g_piDevice->Clear(0,NULL,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, + g_piDevice->Clear(0,nullptr,D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0xFF,0xFF,0,0xFF), 1.0f,0 ); return 1; } } // clear the depth buffer only - g_piDevice->Clear(0,NULL,D3DCLEAR_ZBUFFER, + g_piDevice->Clear(0,nullptr,D3DCLEAR_ZBUFFER, D3DCOLOR_ARGB(0xFF,0xFF,0,0xFF), 1.0f,0 ); // setup the colors to be used ... diff --git a/tools/assimp_view/HelpDialog.cpp b/tools/assimp_view/HelpDialog.cpp index 70b2ac866..d1f34cbf5 100644 --- a/tools/assimp_view/HelpDialog.cpp +++ b/tools/assimp_view/HelpDialog.cpp @@ -53,8 +53,8 @@ INT_PTR CALLBACK HelpDialogProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM ) { case WM_INITDIALOG: { // load the help file ... - HRSRC res = FindResource(NULL,MAKEINTRESOURCE(IDR_TEXT1),"TEXT"); - HGLOBAL hg = LoadResource(NULL,res); + HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_TEXT1),"TEXT"); + HGLOBAL hg = LoadResource(nullptr,res); void* pData = LockResource(hg); SETTEXTEX sInfo; diff --git a/tools/assimp_view/LogDisplay.cpp b/tools/assimp_view/LogDisplay.cpp index ff5ed8680..9f71fbae7 100644 --- a/tools/assimp_view/LogDisplay.cpp +++ b/tools/assimp_view/LogDisplay.cpp @@ -117,29 +117,29 @@ void CLogDisplay::OnRender() { sCopy.top = sWndRect.top+1; sCopy.bottom = sWndRect.bottom+1; sCopy.right = sWndRect.right+1; - this->piFont->DrawText(NULL,szText , + this->piFont->DrawText(nullptr,szText , -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0)); sCopy.left = sWndRect.left+1; sCopy.top = sWndRect.top+1; sCopy.bottom = sWndRect.bottom-1; sCopy.right = sWndRect.right-1; - this->piFont->DrawText(NULL,szText , + this->piFont->DrawText(nullptr,szText , -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0)); sCopy.left = sWndRect.left-1; sCopy.top = sWndRect.top-1; sCopy.bottom = sWndRect.bottom+1; sCopy.right = sWndRect.right+1; - this->piFont->DrawText(NULL,szText , + this->piFont->DrawText(nullptr,szText , -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0)); sCopy.left = sWndRect.left-1; sCopy.top = sWndRect.top-1; sCopy.bottom = sWndRect.bottom-1; sCopy.right = sWndRect.right-1; - this->piFont->DrawText(NULL,szText , + this->piFont->DrawText(nullptr,szText , -1,&sCopy,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(100,0x0,0x0,0x0)); // text - this->piFont->DrawText(NULL,szText , + this->piFont->DrawText(nullptr,szText , -1,&sWndRect,DT_CENTER | DT_VCENTER,D3DCOLOR_ARGB(0xFF,0xFF,0xFF,0xFF)); } @@ -176,7 +176,7 @@ void CLogDisplay::OnRender() { sCopy.top = sRect.top+1; sCopy.bottom = sRect.bottom+1; sCopy.right = sRect.right+1; - this->piFont->DrawText(NULL,szText, + this->piFont->DrawText(nullptr,szText, -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB( (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0)); @@ -184,7 +184,7 @@ void CLogDisplay::OnRender() { sCopy.top = sRect.top-1; sCopy.bottom = sRect.bottom-1; sCopy.right = sRect.right-1; - this->piFont->DrawText(NULL,szText, + this->piFont->DrawText(nullptr,szText, -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB( (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0)); @@ -192,7 +192,7 @@ void CLogDisplay::OnRender() { sCopy.top = sRect.top-1; sCopy.bottom = sRect.bottom+1; sCopy.right = sRect.right+1; - this->piFont->DrawText(NULL,szText, + this->piFont->DrawText(nullptr,szText, -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB( (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0)); @@ -200,12 +200,12 @@ void CLogDisplay::OnRender() { sCopy.top = sRect.top+1; sCopy.bottom = sRect.bottom-1; sCopy.right = sRect.right-1; - this->piFont->DrawText(NULL,szText, + this->piFont->DrawText(nullptr,szText, -1,&sCopy,DT_RIGHT | DT_TOP,D3DCOLOR_ARGB( (unsigned char)(fAlpha * 100.0f),0x0,0x0,0x0)); // draw the text itself - int iPX = this->piFont->DrawText(NULL,szText, + int iPX = this->piFont->DrawText(nullptr,szText, -1,&sRect,DT_RIGHT | DT_TOP,clrColor); sRect.top += iPX; diff --git a/tools/assimp_view/LogWindow.cpp b/tools/assimp_view/LogWindow.cpp index ff6e71038..13abd50f3 100644 --- a/tools/assimp_view/LogWindow.cpp +++ b/tools/assimp_view/LogWindow.cpp @@ -70,7 +70,7 @@ static const char* AI_VIEW_RTF_LOG_HEADER = // Message procedure for the log window //------------------------------------------------------------------------------- INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg, - WPARAM wParam,LPARAM lParam) + WPARAM /*wParam*/,LPARAM lParam) { (void)lParam; switch (uMsg) @@ -86,7 +86,7 @@ INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg, int x = LOWORD(lParam); int y = HIWORD(lParam); - SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),NULL,0,0, + SetWindowPos(GetDlgItem(hwndDlg,IDC_EDIT1),nullptr,0,0, x-10,y-12,SWP_NOMOVE|SWP_NOZORDER); return TRUE; @@ -103,7 +103,7 @@ INT_PTR CALLBACK LogDialogProc(HWND hwndDlg,UINT uMsg, //------------------------------------------------------------------------------- void CLogWindow::Init () { this->hwnd = ::CreateDialog(g_hInstance,MAKEINTRESOURCE(IDD_LOGVIEW), - NULL,&LogDialogProc); + nullptr,&LogDialogProc); if (!this->hwnd) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to create logger window", @@ -156,7 +156,7 @@ void CLogWindow::Save() { char szFileName[MAX_PATH]; DWORD dwTemp = MAX_PATH; - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LogDestination",NULL,NULL,(BYTE*)szFileName,&dwTemp)) { + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LogDestination",nullptr,nullptr,(BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: strcpy(szFileName,""); } else { @@ -169,12 +169,12 @@ void CLogWindow::Save() { } OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), - "Log files\0*.txt", NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + g_hDlg,GetModuleHandle(nullptr), + "Log files\0*.txt", nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Save log to file", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ".txt", 0, NULL, NULL + 0, 1, ".txt", 0, nullptr, nullptr }; if(GetSaveFileName(&sFilename1) == 0) return; diff --git a/tools/assimp_view/Material.cpp b/tools/assimp_view/Material.cpp index 0d504e9fb..d57408403 100644 --- a/tools/assimp_view/Material.cpp +++ b/tools/assimp_view/Material.cpp @@ -210,15 +210,15 @@ int CMaterialManager::SetDefaultTexture(IDirect3DTexture9** p_ppiOut) D3DFMT_A8R8G8B8, D3DPOOL_MANAGED, p_ppiOut, - NULL))) + nullptr))) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to create default texture", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); - *p_ppiOut = NULL; + *p_ppiOut = nullptr; return 0; } - D3DXFillTexture(*p_ppiOut,&FillFunc,NULL); + D3DXFillTexture(*p_ppiOut,&FillFunc,nullptr); sDefaultTexture = *p_ppiOut; sDefaultTexture->AddRef(); @@ -287,7 +287,7 @@ bool CMaterialManager::TryLongerPath(char* szTemp,aiString* p_szString) size_t iLen2 = iLen+1; iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2; memcpy(p_szString->data,szTempB,iLen2); - p_szString->length = iLen; + p_szString->length = static_cast(iLen); return true; } } @@ -301,7 +301,7 @@ bool CMaterialManager::TryLongerPath(char* szTemp,aiString* p_szString) size_t iLen2 = iLen+1; iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2; memcpy(p_szString->data,szTempB,iLen2); - p_szString->length = iLen; + p_szString->length = static_cast(iLen); return true; } } @@ -316,7 +316,7 @@ bool CMaterialManager::TryLongerPath(char* szTemp,aiString* p_szString) //------------------------------------------------------------------------------- int CMaterialManager::FindValidPath(aiString* p_szString) { - ai_assert(NULL != p_szString); + ai_assert(nullptr != p_szString); aiString pcpy = *p_szString; if ('*' == p_szString->data[0]) { // '*' as first character indicates an embedded file @@ -389,10 +389,10 @@ int CMaterialManager::FindValidPath(aiString* p_szString) if( !q ) q=strrchr( tmp2,'\\' ); if( q ){ strcpy( q+1,p+1 ); - if((pFile=fopen( tmp2,"r" ))){ + if((pFile=fopen( tmp2,"r" )) != nullptr){ fclose( pFile ); strcpy(p_szString->data,tmp2); - p_szString->length = strlen(tmp2); + p_szString->length = static_cast(strlen(tmp2)); return 1; } } @@ -407,7 +407,7 @@ int CMaterialManager::FindValidPath(aiString* p_szString) size_t iLen2 = iLen+1; iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2; memcpy(p_szString->data,szTemp,iLen2); - p_szString->length = iLen; + p_szString->length = static_cast(iLen); } return 1; @@ -415,10 +415,10 @@ int CMaterialManager::FindValidPath(aiString* p_szString) //------------------------------------------------------------------------------- int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath) { - ai_assert(NULL != p_ppiOut); - ai_assert(NULL != szPath); + ai_assert(nullptr != p_ppiOut); + ai_assert(nullptr != szPath); - *p_ppiOut = NULL; + *p_ppiOut = nullptr; const std::string s = szPath->data; TextureCache::iterator ff; @@ -453,7 +453,7 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath) D3DX_DEFAULT, 0, &info, - NULL, + nullptr, p_ppiOut))) { std::string sz = "[ERROR] Unable to load embedded texture (#1): "; @@ -470,7 +470,7 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath) if(FAILED(g_piDevice->CreateTexture( g_pcAsset->pcScene->mTextures[iIndex]->mWidth, g_pcAsset->pcScene->mTextures[iIndex]->mHeight, - 0,D3DUSAGE_AUTOGENMIPMAP,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,p_ppiOut,NULL))) + 0,D3DUSAGE_AUTOGENMIPMAP,D3DFMT_A8R8G8B8,D3DPOOL_MANAGED,p_ppiOut,nullptr))) { std::string sz = "[ERROR] Unable to load embedded texture (#2): "; sz.append(szPath->data); @@ -482,7 +482,7 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath) // now copy the data to it ... (assume non pow2 to be supported) D3DLOCKED_RECT sLock; - (*p_ppiOut)->LockRect(0,&sLock,NULL,0); + (*p_ppiOut)->LockRect(0,&sLock,nullptr,0); const aiTexel* pcData = g_pcAsset->pcScene->mTextures[iIndex]->pcData; @@ -524,8 +524,8 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath) D3DX_DEFAULT, D3DX_DEFAULT, 0, - NULL, - NULL, + nullptr, + nullptr, p_ppiOut))) { // error ... use the default texture instead @@ -550,44 +550,44 @@ void CMaterialManager::DeleteMaterial(AssetHelper::MeshHelper* pcIn) if (pcIn->piDiffuseTexture) { pcIn->piDiffuseTexture->Release(); - pcIn->piDiffuseTexture = NULL; + pcIn->piDiffuseTexture = nullptr; } if (pcIn->piSpecularTexture) { pcIn->piSpecularTexture->Release(); - pcIn->piSpecularTexture = NULL; + pcIn->piSpecularTexture = nullptr; } if (pcIn->piEmissiveTexture) { pcIn->piEmissiveTexture->Release(); - pcIn->piEmissiveTexture = NULL; + pcIn->piEmissiveTexture = nullptr; } if (pcIn->piAmbientTexture) { pcIn->piAmbientTexture->Release(); - pcIn->piAmbientTexture = NULL; + pcIn->piAmbientTexture = nullptr; } if (pcIn->piOpacityTexture) { pcIn->piOpacityTexture->Release(); - pcIn->piOpacityTexture = NULL; + pcIn->piOpacityTexture = nullptr; } if (pcIn->piNormalTexture) { pcIn->piNormalTexture->Release(); - pcIn->piNormalTexture = NULL; + pcIn->piNormalTexture = nullptr; } if (pcIn->piShininessTexture) { pcIn->piShininessTexture->Release(); - pcIn->piShininessTexture = NULL; + pcIn->piShininessTexture = nullptr; } if (pcIn->piLightmapTexture) { pcIn->piLightmapTexture->Release(); - pcIn->piLightmapTexture = NULL; + pcIn->piLightmapTexture = nullptr; } - pcIn->piEffect = NULL; + pcIn->piEffect = nullptr; } //------------------------------------------------------------------------------- void CMaterialManager::HMtoNMIfNecessary( @@ -595,8 +595,8 @@ void CMaterialManager::HMtoNMIfNecessary( IDirect3DTexture9** piTextureOut, bool bWasOriginallyHM) { - ai_assert(NULL != piTexture); - ai_assert(NULL != piTextureOut); + ai_assert(nullptr != piTexture); + ai_assert(nullptr != piTextureOut); bool bMustConvert = false; uintptr_t iElement = 3; @@ -617,7 +617,7 @@ void CMaterialManager::HMtoNMIfNecessary( D3DLOCKED_RECT sRect; D3DSURFACE_DESC sDesc; piTexture->GetLevelDesc(0,&sDesc); - if (FAILED(piTexture->LockRect(0,&sRect,NULL,D3DLOCK_READONLY))) + if (FAILED(piTexture->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY))) { return; } @@ -627,7 +627,7 @@ void CMaterialManager::HMtoNMIfNecessary( { union { - struct {unsigned char b,g,r,a;}; + struct {unsigned char b,g,r,a;} data; char _array[4]; }; }; @@ -646,7 +646,7 @@ void CMaterialManager::HMtoNMIfNecessary( { for (unsigned int x = 0; x < sDesc.Width;++x) { - if (pcPointer->b != pcPointer->r || pcPointer->b != pcPointer->g) + if (pcPointer->data.b != pcPointer->data.r || pcPointer->data.b != pcPointer->data.g) { bIsEqual = false; break; @@ -705,9 +705,9 @@ void CMaterialManager::HMtoNMIfNecessary( aiColor3D clrColorLine; for (unsigned int x = 0; x < sDesc.Width;++x) { - clrColorLine.r += pcPointer->r; - clrColorLine.g += pcPointer->g; - clrColorLine.b += pcPointer->b; + clrColorLine.r += pcPointer->data.r; + clrColorLine.g += pcPointer->data.g; + clrColorLine.b += pcPointer->data.b; pcPointer++; } clrColor.r += clrColorLine.r /= (float)sDesc.Width; @@ -739,17 +739,17 @@ void CMaterialManager::HMtoNMIfNecessary( // need to convert it NOW if (bMustConvert) { - D3DSURFACE_DESC sDesc; - piTexture->GetLevelDesc(0, &sDesc); + D3DSURFACE_DESC sDesc2; + piTexture->GetLevelDesc(0, &sDesc2); IDirect3DTexture9* piTempTexture; if(FAILED(g_piDevice->CreateTexture( - sDesc.Width, - sDesc.Height, + sDesc2.Width, + sDesc2.Height, piTexture->GetLevelCount(), - sDesc.Usage, - sDesc.Format, - sDesc.Pool, &piTempTexture, NULL))) + sDesc2.Usage, + sDesc2.Format, + sDesc2.Pool, &piTempTexture, nullptr))) { CLogDisplay::Instance().AddEntry( "[ERROR] Unable to create normal map texture", @@ -764,7 +764,7 @@ void CMaterialManager::HMtoNMIfNecessary( else /*if (0 == iElement)*/dwFlags = D3DX_CHANNEL_BLUE; if(FAILED(D3DXComputeNormalMap(piTempTexture, - piTexture,NULL,0,dwFlags,1.0f))) + piTexture,nullptr,0,dwFlags,1.0f))) { CLogDisplay::Instance().AddEntry( "[ERROR] Unable to compute normal map from height map", @@ -780,12 +780,12 @@ void CMaterialManager::HMtoNMIfNecessary( //------------------------------------------------------------------------------- bool CMaterialManager::HasAlphaPixels(IDirect3DTexture9* piTexture) { - ai_assert(NULL != piTexture); + ai_assert(nullptr != piTexture); D3DLOCKED_RECT sRect; D3DSURFACE_DESC sDesc; piTexture->GetLevelDesc(0,&sDesc); - if (FAILED(piTexture->LockRect(0,&sRect,NULL,D3DLOCK_READONLY))) + if (FAILED(piTexture->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY))) { return false; } @@ -823,8 +823,8 @@ bool CMaterialManager::HasAlphaPixels(IDirect3DTexture9* piTexture) int CMaterialManager::CreateMaterial( AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource) { - ai_assert(NULL != pcMesh); - ai_assert(NULL != pcSource); + ai_assert(nullptr != pcMesh); + ai_assert(nullptr != pcSource); ID3DXBuffer* piBuffer; @@ -1060,29 +1060,29 @@ int CMaterialManager::CreateMaterial( } AssetHelper::MeshHelper* pc = g_pcAsset->apcMeshes[i]; - if ((pcMesh->piDiffuseTexture != NULL ? true : false) != - (pc->piDiffuseTexture != NULL ? true : false)) + if ((pcMesh->piDiffuseTexture != nullptr ? true : false) != + (pc->piDiffuseTexture != nullptr ? true : false)) continue; - if ((pcMesh->piSpecularTexture != NULL ? true : false) != - (pc->piSpecularTexture != NULL ? true : false)) + if ((pcMesh->piSpecularTexture != nullptr ? true : false) != + (pc->piSpecularTexture != nullptr ? true : false)) continue; - if ((pcMesh->piAmbientTexture != NULL ? true : false) != - (pc->piAmbientTexture != NULL ? true : false)) + if ((pcMesh->piAmbientTexture != nullptr ? true : false) != + (pc->piAmbientTexture != nullptr ? true : false)) continue; - if ((pcMesh->piEmissiveTexture != NULL ? true : false) != - (pc->piEmissiveTexture != NULL ? true : false)) + if ((pcMesh->piEmissiveTexture != nullptr ? true : false) != + (pc->piEmissiveTexture != nullptr ? true : false)) continue; - if ((pcMesh->piNormalTexture != NULL ? true : false) != - (pc->piNormalTexture != NULL ? true : false)) + if ((pcMesh->piNormalTexture != nullptr ? true : false) != + (pc->piNormalTexture != nullptr ? true : false)) continue; - if ((pcMesh->piOpacityTexture != NULL ? true : false) != - (pc->piOpacityTexture != NULL ? true : false)) + if ((pcMesh->piOpacityTexture != nullptr ? true : false) != + (pc->piOpacityTexture != nullptr ? true : false)) continue; - if ((pcMesh->piShininessTexture != NULL ? true : false) != - (pc->piShininessTexture != NULL ? true : false)) + if ((pcMesh->piShininessTexture != nullptr ? true : false) != + (pc->piShininessTexture != nullptr ? true : false)) continue; - if ((pcMesh->piLightmapTexture != NULL ? true : false) != - (pc->piLightmapTexture != NULL ? true : false)) + if ((pcMesh->piLightmapTexture != nullptr ? true : false) != + (pc->piLightmapTexture != nullptr ? true : false)) continue; if ((pcMesh->eShadingMode != aiShadingMode_Gouraud ? true : false) != (pc->eShadingMode != aiShadingMode_Gouraud ? true : false)) @@ -1239,13 +1239,13 @@ int CMaterialManager::CreateMaterial( sMacro[iCurrent].Definition = "1"; ++iCurrent; } - sMacro[iCurrent].Name = NULL; - sMacro[iCurrent].Definition = NULL; + sMacro[iCurrent].Name = nullptr; + sMacro[iCurrent].Definition = nullptr; // compile the shader if(FAILED( D3DXCreateEffect(g_piDevice, g_szMaterialShader.c_str(),(UINT)g_szMaterialShader.length(), - (const D3DXMACRO*)sMacro,NULL,0,NULL,&pcMesh->piEffect,&piBuffer))) + (const D3DXMACRO*)sMacro,nullptr,0,nullptr,&pcMesh->piEffect,&piBuffer))) { // failed to compile the shader if( piBuffer) @@ -1333,7 +1333,7 @@ int CMaterialManager::SetupMaterial ( const aiMatrix4x4& pcCam, const aiVector3D& vPos) { - ai_assert(NULL != pcMesh); + ai_assert(nullptr != pcMesh); if (!pcMesh->piEffect)return 0; ID3DXEffect* piEnd = pcMesh->piEffect; @@ -1476,7 +1476,7 @@ int CMaterialManager::SetupMaterial ( //------------------------------------------------------------------------------- int CMaterialManager::EndMaterial (AssetHelper::MeshHelper* pcMesh) { - ai_assert(NULL != pcMesh); + ai_assert(nullptr != pcMesh); if (!pcMesh->piEffect)return 0; // end the effect diff --git a/tools/assimp_view/MessageProc.cpp b/tools/assimp_view/MessageProc.cpp index 3000e557b..80589e647 100644 --- a/tools/assimp_view/MessageProc.cpp +++ b/tools/assimp_view/MessageProc.cpp @@ -60,13 +60,13 @@ using namespace Assimp; COLORREF g_aclCustomColors[16] = {0}; // Global registry key -HKEY g_hRegistry = NULL; +HKEY g_hRegistry = nullptr; // list of previous files (always 5) std::vector g_aPreviousFiles; // history menu item -HMENU g_hHistoryMenu = NULL; +HMENU g_hHistoryMenu = nullptr; float g_fACMR = 3.0f; @@ -89,10 +89,10 @@ void MakeFileAssociations() { char szTemp2[MAX_PATH]; char szTemp[MAX_PATH + 10]; - GetModuleFileName(NULL,szTemp2,MAX_PATH); + GetModuleFileName(nullptr,szTemp2,MAX_PATH); sprintf(szTemp,"%s %%1",szTemp2); - HKEY hRegistry = NULL; + HKEY hRegistry = nullptr; aiString list, tmp; aiGetExtensionList(&list); @@ -104,15 +104,15 @@ void MakeFileAssociations() { ai_assert(sz[0] == '*'); sprintf(buf,"Software\\Classes\\%s",sz+1); - RegCreateKeyEx(HKEY_CURRENT_USER,buf,0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL); + RegCreateKeyEx(HKEY_CURRENT_USER,buf,0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr); RegSetValueEx(hRegistry,"",0,REG_SZ,(const BYTE*)"ASSIMPVIEW_CLASS",(DWORD)strlen("ASSIMPVIEW_CLASS")+1); RegCloseKey(hRegistry); - } while ((sz = strtok(NULL,";"))); + } while ((sz = strtok(nullptr,";")) != nullptr); - RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS",0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL); + RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr); RegCloseKey(hRegistry); - RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS\\shell\\open\\command",0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL); + RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\Classes\\ASSIMPVIEW_CLASS\\shell\\open\\command",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr); RegSetValueEx(hRegistry,"",0,REG_SZ,(const BYTE*)szTemp,(DWORD)strlen(szTemp)+1); RegCloseKey(hRegistry); @@ -157,9 +157,9 @@ void HandleCommandLine(char* p_szCommand) { //------------------------------------------------------------------------------- void LoadLightColors() { DWORD dwTemp = 4; - RegQueryValueEx(g_hRegistry,"LightColor0",NULL,NULL, (BYTE*)&g_avLightColors[0],&dwTemp); - RegQueryValueEx(g_hRegistry,"LightColor1",NULL,NULL, (BYTE*)&g_avLightColors[1],&dwTemp); - RegQueryValueEx(g_hRegistry,"LightColor2",NULL,NULL, (BYTE*)&g_avLightColors[2],&dwTemp); + RegQueryValueEx(g_hRegistry,"LightColor0",nullptr,nullptr, (BYTE*)&g_avLightColors[0],&dwTemp); + RegQueryValueEx(g_hRegistry,"LightColor1",nullptr,nullptr, (BYTE*)&g_avLightColors[1],&dwTemp); + RegQueryValueEx(g_hRegistry,"LightColor2",nullptr,nullptr, (BYTE*)&g_avLightColors[2],&dwTemp); } //------------------------------------------------------------------------------- @@ -190,10 +190,10 @@ void SaveCheckerPatternColors() { //------------------------------------------------------------------------------- void LoadCheckerPatternColors() { DWORD dwTemp = sizeof(D3DXVECTOR3); - RegQueryValueEx(g_hRegistry,"CheckerPattern0",NULL,NULL, + RegQueryValueEx(g_hRegistry,"CheckerPattern0",nullptr,nullptr, (BYTE*) /* jep, this is evil */ CDisplay::Instance().GetFirstCheckerColor(),&dwTemp); - RegQueryValueEx(g_hRegistry,"CheckerPattern1",NULL,NULL, + RegQueryValueEx(g_hRegistry,"CheckerPattern1",nullptr,nullptr, (BYTE*) /* jep, this is evil */ CDisplay::Instance().GetSecondCheckerColor(),&dwTemp); } @@ -372,13 +372,13 @@ void ToggleUIState() { sRect2.top -= sRect.top; if (BST_UNCHECKED == IsDlgButtonChecked(g_hDlg,IDC_BLUBB)) { - SetWindowPos(g_hDlg,NULL,0,0,sRect.right-214,sRect.bottom, + SetWindowPos(g_hDlg,nullptr,0,0,sRect.right-214,sRect.bottom, SWP_NOMOVE | SWP_NOZORDER); SetWindowText(GetDlgItem(g_hDlg,IDC_BLUBB),">>"); storeRegKey(false, "MultiSampling"); } else { - SetWindowPos(g_hDlg,NULL,0,0,sRect.right+214,sRect.bottom, + SetWindowPos(g_hDlg,nullptr,0,0,sRect.right+214,sRect.bottom, SWP_NOMOVE | SWP_NOZORDER); storeRegKey(true, "LastUIState"); @@ -394,7 +394,7 @@ void LoadBGTexture() { char szFileName[MAX_PATH]; DWORD dwTemp = MAX_PATH; - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureSrc",NULL,NULL, (BYTE*)szFileName,&dwTemp)) { + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"TextureSrc",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: strcpy(szFileName,""); } else { @@ -407,13 +407,13 @@ void LoadBGTexture() { } OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), + g_hDlg,GetModuleHandle(nullptr), "Textures\0*.png;*.dds;*.tga;*.bmp;*.tif;*.ppm;*.ppx;*.jpg;*.jpeg;*.exr\0*.*\0", - NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Open texture as background", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ".jpg", 0, NULL, NULL + 0, 1, ".jpg", 0, nullptr, nullptr }; if(GetOpenFileName(&sFilename1) == 0) return; @@ -448,8 +448,8 @@ void DisplayColorDialog(D3DCOLOR* pclrResult) { clr.Flags = CC_RGBINIT | CC_FULLOPEN; clr.rgbResult = RGB((*pclrResult >> 16) & 0xff,(*pclrResult >> 8) & 0xff,*pclrResult & 0xff); clr.lpCustColors = g_aclCustomColors; - clr.lpfnHook = NULL; - clr.lpTemplateName = NULL; + clr.lpfnHook = nullptr; + clr.lpTemplateName = nullptr; clr.lCustData = 0; ChooseColor(&clr); @@ -472,8 +472,8 @@ void DisplayColorDialog(D3DXVECTOR4* pclrResult) { clamp(pclrResult->y * 255.0f), clamp(pclrResult->z * 255.0f)); clr.lpCustColors = g_aclCustomColors; - clr.lpfnHook = NULL; - clr.lpTemplateName = NULL; + clr.lpfnHook = nullptr; + clr.lpTemplateName = nullptr; clr.lCustData = 0; ChooseColor(&clr); @@ -504,7 +504,7 @@ void LoadSkybox() { char szFileName[MAX_PATH]; DWORD dwTemp = MAX_PATH; - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"SkyBoxSrc",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"SkyBoxSrc",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: @@ -521,12 +521,12 @@ void LoadSkybox() { } OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), - "Skyboxes\0*.dds\0*.*\0", NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + g_hDlg,GetModuleHandle(nullptr), + "Skyboxes\0*.dds\0*.*\0", nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Open skybox as background", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ".dds", 0, NULL, NULL + 0, 1, ".dds", 0, nullptr, nullptr }; if(GetOpenFileName(&sFilename1) == 0) return; @@ -555,7 +555,7 @@ void SaveScreenshot() { char szFileName[MAX_PATH]; DWORD dwTemp = MAX_PATH; - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ScreenShot",NULL,NULL, (BYTE*)szFileName,&dwTemp)) { + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"ScreenShot",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: strcpy(szFileName,""); } else { @@ -568,21 +568,21 @@ void SaveScreenshot() { } OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), - "PNG Images\0*.png", NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + g_hDlg,GetModuleHandle(nullptr), + "PNG Images\0*.png", nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Save Screenshot to file", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ".png", 0, NULL, NULL + 0, 1, ".png", 0, nullptr, nullptr }; if(GetSaveFileName(&sFilename1) == 0) return; // Now store the file in the registry RegSetValueExA(g_hRegistry,"ScreenShot",0,REG_SZ,(const BYTE*)szFileName,MAX_PATH); - IDirect3DSurface9* pi = NULL; + IDirect3DSurface9* pi = nullptr; g_piDevice->GetRenderTarget(0,&pi); - if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,D3DXIFF_PNG,pi,NULL,NULL))) { + if(!pi || FAILED(D3DXSaveSurfaceToFile(szFileName,D3DXIFF_PNG,pi,nullptr,nullptr))) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to save screenshot", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); } else { @@ -751,7 +751,7 @@ void LoadHistory() { DWORD dwTemp = MAX_PATH; szFileName[0] ='\0'; - if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,szName,NULL,NULL, + if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,szName,nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { g_aPreviousFiles[i] = std::string(szFileName); } @@ -826,7 +826,7 @@ void OpenAsset() { char szFileName[MAX_PATH]; DWORD dwTemp = MAX_PATH; - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"CurrentApp",NULL,NULL, (BYTE*)szFileName,&dwTemp)) { + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"CurrentApp",nullptr,nullptr, (BYTE*)szFileName,&dwTemp)) { // Key was not found. Use C: strcpy(szFileName,""); } else { @@ -856,15 +856,15 @@ void OpenAsset() { ZeroMemory(&sFilename1, sizeof(sFilename1)); sFilename1.lStructSize = sizeof(sFilename1); sFilename1.hwndOwner = g_hDlg; - sFilename1.hInstance = GetModuleHandle(NULL); + sFilename1.hInstance = GetModuleHandle(nullptr); sFilename1.lpstrFile = szFileName; sFilename1.lpstrFile[0] = '\0'; sFilename1.nMaxFile = sizeof(szList); sFilename1.lpstrFilter = szList; sFilename1.nFilterIndex = 1; - sFilename1.lpstrFileTitle = NULL; + sFilename1.lpstrFileTitle = nullptr; sFilename1.nMaxFileTitle = 0; - sFilename1.lpstrInitialDir = NULL; + sFilename1.lpstrInitialDir = nullptr; sFilename1.Flags = OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR; if (GetOpenFileName(&sFilename1) == 0) { return; @@ -942,7 +942,7 @@ void DoExport(size_t formatId) { char szFileName[MAX_PATH*2]; DWORD dwTemp = sizeof(szFileName); - if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,"ModelExportDest",NULL,NULL,(BYTE*)szFileName, &dwTemp)) { + if(ERROR_SUCCESS == RegQueryValueEx(g_hRegistry,"ModelExportDest",nullptr,nullptr,(BYTE*)szFileName, &dwTemp)) { ai_assert(strlen(szFileName) <= MAX_PATH); // invent a nice default file name @@ -975,12 +975,12 @@ void DoExport(size_t formatId) { const std::string ext = "."+std::string(e->fileExtension); OPENFILENAME sFilename1 = { sizeof(OPENFILENAME), - g_hDlg,GetModuleHandle(NULL), - desc, NULL, 0, 1, - szFileName, MAX_PATH, NULL, 0, NULL, + g_hDlg,GetModuleHandle(nullptr), + desc, nullptr, 0, 1, + szFileName, MAX_PATH, nullptr, 0, nullptr, "Export asset", OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY | OFN_NOCHANGEDIR, - 0, 1, ext.c_str(), 0, NULL, NULL + 0, 1, ext.c_str(), 0, nullptr, nullptr }; if(::GetSaveFileName(&sFilename1) == 0) { return; @@ -1036,9 +1036,9 @@ void InitUI() { // store the key in a global variable for later use RegCreateKeyEx(HKEY_CURRENT_USER,"Software\\ASSIMP\\Viewer", - 0,NULL,0,KEY_ALL_ACCESS, NULL, &g_hRegistry,NULL); + 0,nullptr,0,KEY_ALL_ACCESS, nullptr, &g_hRegistry,nullptr); - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LastUIState",NULL,NULL, (BYTE*)&dwValue,&dwTemp)) { + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LastUIState",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp)) { dwValue = 1; } if (0 == dwValue) { @@ -1054,7 +1054,7 @@ void InitUI() { sRect2.left -= sRect.left; sRect2.top -= sRect.top; - SetWindowPos(g_hDlg,NULL,0,0,sRect.right-214,sRect.bottom, + SetWindowPos(g_hDlg,nullptr,0,0,sRect.right-214,sRect.bottom, SWP_NOMOVE | SWP_NOZORDER); SetWindowText(GetDlgItem(g_hDlg,IDC_BLUBB),">>"); } else { @@ -1062,7 +1062,7 @@ void InitUI() { } // AutoRotate - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"AutoRotate",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"AutoRotate",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_sOptions.bRotate = false; @@ -1073,7 +1073,7 @@ void InitUI() { } // MultipleLights - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultipleLights",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultipleLights",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_sOptions.b3Lights = false; @@ -1084,7 +1084,7 @@ void InitUI() { } // Light rotate - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LightRotate",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LightRotate",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_sOptions.bLightRotate = false; @@ -1095,7 +1095,7 @@ void InitUI() { } // NoSpecular - if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "NoSpecular", NULL, NULL, (BYTE*)&dwValue, &dwTemp)) { + if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "NoSpecular", nullptr, nullptr, (BYTE*)&dwValue, &dwTemp)) { dwValue = 0; } if (0 == dwValue) { @@ -1107,7 +1107,7 @@ void InitUI() { } // LowQuality - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LowQuality",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"LowQuality",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_sOptions.bLowQuality = false; @@ -1118,7 +1118,7 @@ void InitUI() { } // LowQuality - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"NoTransparency",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"NoTransparency",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_sOptions.bNoAlphaBlending = false; @@ -1129,7 +1129,7 @@ void InitUI() { } // DisplayNormals - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"RenderNormals",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"RenderNormals",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_sOptions.bRenderNormals = false; @@ -1140,7 +1140,7 @@ void InitUI() { } // NoMaterials - if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "RenderMats", NULL, NULL, + if (ERROR_SUCCESS != RegQueryValueEx(g_hRegistry, "RenderMats", nullptr, nullptr, (BYTE*)&dwValue, &dwTemp)) { dwValue = 1; } @@ -1153,7 +1153,7 @@ void InitUI() { } // MultiSampling - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultiSampling",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"MultiSampling",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 1; if (0 == dwValue) { @@ -1165,7 +1165,7 @@ void InitUI() { } // FPS Mode - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"FPSView",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"FPSView",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { g_bFPSView = false; @@ -1176,7 +1176,7 @@ void InitUI() { } // WireFrame - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"Wireframe",NULL,NULL, + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"Wireframe",nullptr,nullptr, (BYTE*)&dwValue,&dwTemp))dwValue = 0; if (0 == dwValue) { @@ -1189,7 +1189,7 @@ void InitUI() { CheckDlgButton(g_hDlg,IDC_TOGGLEWIRE,BST_CHECKED); } - if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"PostProcessing",NULL,NULL,(BYTE*)&dwValue,&dwTemp)) + if(ERROR_SUCCESS != RegQueryValueEx(g_hRegistry,"PostProcessing",nullptr,nullptr,(BYTE*)&dwValue,&dwTemp)) ppsteps = ppstepsdefault; else ppsteps = dwValue; @@ -1458,7 +1458,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam if (bDraw) { SetBkColor(pcStruct->hDC,RGB(0,0,0)); - MoveToEx(pcStruct->hDC,0,0,NULL); + MoveToEx(pcStruct->hDC,0,0,nullptr); LineTo(pcStruct->hDC,sRect.right-1,0); LineTo(pcStruct->hDC,sRect.right-1,sRect.bottom-1); LineTo(pcStruct->hDC,0,sRect.bottom-1); @@ -1534,7 +1534,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam g_eClick = EClickPos_Outside; if (xPos2 >= fHalfX && xPos2 < fHalfX + (int)sDesc.Width && yPos2 >= fHalfY && yPos2 < fHalfY + (int)sDesc.Height && - NULL != g_szImageMask) + nullptr != g_szImageMask) { // inside the texture. Lookup the grayscale value from it xPos2 -= fHalfX; @@ -1710,13 +1710,13 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam } else if (ID_TOOLS_LOGWINDOW == LOWORD(wParam)) { CLogWindow::Instance().Show(); } else if (ID__WEBSITE == LOWORD(wParam)) { - ShellExecute(NULL,"open","http://assimp.sourceforge.net","","",SW_SHOW); + ShellExecute(nullptr,"open","http://assimp.sourceforge.net","","",SW_SHOW); } else if (ID__WEBSITESF == LOWORD(wParam)) { - ShellExecute(NULL,"open","https://sourceforge.net/projects/assimp","","",SW_SHOW); + ShellExecute(nullptr,"open","https://sourceforge.net/projects/assimp","","",SW_SHOW); } else if (ID_REPORTBUG == LOWORD(wParam)) { - ShellExecute(NULL,"open","https://sourceforge.net/tracker/?func=add&group_id=226462&atid=1067632","","",SW_SHOW); + ShellExecute(nullptr,"open","https://sourceforge.net/tracker/?func=add&group_id=226462&atid=1067632","","",SW_SHOW); } else if (ID_FR == LOWORD(wParam)) { - ShellExecute(NULL,"open","https://sourceforge.net/forum/forum.php?forum_id=817653","","",SW_SHOW); + ShellExecute(nullptr,"open","https://sourceforge.net/forum/forum.php?forum_id=817653","","",SW_SHOW); } else if (ID_TOOLS_CLEARLOG == LOWORD(wParam)) { CLogWindow::Instance().Clear(); } else if (ID_TOOLS_SAVELOGTOFILE == LOWORD(wParam)) { @@ -1838,7 +1838,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam } else if (ID_IMPORTSETTINGS_OPENPOST == LOWORD(wParam)) { - ShellExecute(NULL,"open","http://assimp.sourceforge.net/lib_html/ai_post_process_8h.html","","",SW_SHOW); + ShellExecute(nullptr,"open","http://assimp.sourceforge.net/lib_html/ai_post_process_8h.html","","",SW_SHOW); } else if (ID_TOOLS_ORIGINALNORMALS == LOWORD(wParam)) { @@ -1922,7 +1922,7 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam DisplayColorDialog(&g_avLightColors[0]); SaveLightColors(); } - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR1)); } else if (IDC_LCOLOR2 == LOWORD(wParam)) @@ -1939,13 +1939,13 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam DisplayColorDialog(&g_avLightColors[1]); SaveLightColors(); } - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR2)); } else if (IDC_LCOLOR3 == LOWORD(wParam)) { DisplayColorDialog(&g_avLightColors[2]); - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR3)); SaveLightColors(); } @@ -1966,11 +1966,11 @@ INT_PTR CALLBACK MessageProc(HWND hwndDlg,UINT uMsg, WPARAM wParam,LPARAM lParam SaveLightColors(); } - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR1),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR1)); - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR2)); - InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,TRUE); + InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),nullptr,TRUE); UpdateWindow(GetDlgItem(g_hDlg,IDC_LCOLOR3)); } else if (IDC_NOSPECULAR == LOWORD(wParam)) @@ -2076,7 +2076,7 @@ INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg,UINT uMsg, SendDlgItemMessage(hwndDlg,IDC_PROGRESS,PBM_SETRANGE,0, MAKELPARAM(0,500)); - SetTimer(hwndDlg,0,40,NULL); + SetTimer(hwndDlg,0,40,nullptr); return TRUE; case WM_CLOSE: @@ -2090,7 +2090,7 @@ INT_PTR CALLBACK ProgressMessageProc(HWND hwndDlg,UINT uMsg, #if 0 g_bLoadingCanceled = true; TerminateThread(g_hThreadHandle,5); - g_pcAsset = NULL; + g_pcAsset = nullptr; EndDialog(hwndDlg,0); #endif @@ -2167,14 +2167,14 @@ int APIENTRY _tWinMain(HINSTANCE hInstance, // initialize the IDirect3D9 interface g_hInstance = hInstance; if (0 == InitD3D()) { - MessageBox(NULL,"Failed to initialize Direct3D 9", + MessageBox(nullptr,"Failed to initialize Direct3D 9", "ASSIMP ModelViewer",MB_OK); return -6; } // create the main dialog HWND hDlg = CreateDialog(hInstance,MAKEINTRESOURCE(IDD_DIALOGMAIN), - NULL,&MessageProc); + nullptr,&MessageProc); // ensure we get high priority ::SetPriorityClass(GetCurrentProcess(),HIGH_PRIORITY_CLASS); @@ -2187,8 +2187,8 @@ int APIENTRY _tWinMain(HINSTANCE hInstance, Assimp::DefaultLogger::Debugging | Assimp::DefaultLogger::Info | Assimp::DefaultLogger::Err | Assimp::DefaultLogger::Warn); - if (NULL == hDlg) { - MessageBox(NULL,"Failed to create dialog from resource", + if (nullptr == hDlg) { + MessageBox(nullptr,"Failed to create dialog from resource", "ASSIMP ModelViewer",MB_OK); return -5; } @@ -2202,7 +2202,7 @@ int APIENTRY _tWinMain(HINSTANCE hInstance, // create the D3D device object if (0 == CreateDevice(g_sOptions.bMultiSample,false,true)) { - MessageBox(NULL,"Failed to initialize Direct3D 9 (2)", + MessageBox(nullptr,"Failed to initialize Direct3D 9 (2)", "ASSIMP ModelViewer",MB_OK); return -4; } @@ -2222,18 +2222,18 @@ int APIENTRY _tWinMain(HINSTANCE hInstance, }; DWORD dwTemp = MAX_PATH; RegCreateKeyEx(HKEY_CURRENT_USER, - "Software\\ASSIMP\\Viewer",0,NULL,0,KEY_ALL_ACCESS, NULL, &hRegistry,NULL); - if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastSkyBoxSrc",NULL,NULL, + "Software\\ASSIMP\\Viewer",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr); + if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastSkyBoxSrc",nullptr,nullptr, (BYTE*)szFileName,&dwTemp) && '\0' != szFileName[0]) { CBackgroundPainter::Instance().SetCubeMapBG(szFileName); } - else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastTextureSrc",NULL,NULL, + else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastTextureSrc",nullptr,nullptr, (BYTE*)szFileName,&dwTemp) && '\0' != szFileName[0]) { CBackgroundPainter::Instance().SetTextureBG(szFileName); } - else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"Color",NULL,NULL, + else if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"Color",nullptr,nullptr, (BYTE*)&clrColor,&dwTemp)) { CBackgroundPainter::Instance().SetColor(clrColor); @@ -2251,7 +2251,7 @@ int APIENTRY _tWinMain(HINSTANCE hInstance, double g_dLastTime = 0; while( uMsg.message != WM_QUIT ) { - if( PeekMessage( &uMsg, NULL, 0, 0, PM_REMOVE ) ) + if( PeekMessage( &uMsg, nullptr, 0, 0, PM_REMOVE ) ) { TranslateMessage( &uMsg ); DispatchMessage( &uMsg ); diff --git a/tools/assimp_view/assimp_view.cpp b/tools/assimp_view/assimp_view.cpp index b8f13b092..79a902b2a 100644 --- a/tools/assimp_view/assimp_view.cpp +++ b/tools/assimp_view/assimp_view.cpp @@ -61,17 +61,17 @@ extern std::string g_szDefaultShader; extern std::string g_szPassThroughShader; //------------------------------------------------------------------------------- -HINSTANCE g_hInstance = NULL; -HWND g_hDlg = NULL; -IDirect3D9* g_piD3D = NULL; -IDirect3DDevice9* g_piDevice = NULL; -IDirect3DVertexDeclaration9* gDefaultVertexDecl = NULL; +HINSTANCE g_hInstance = nullptr; +HWND g_hDlg = nullptr; +IDirect3D9* g_piD3D = nullptr; +IDirect3DDevice9* g_piDevice = nullptr; +IDirect3DVertexDeclaration9* gDefaultVertexDecl = nullptr; double g_fFPS = 0.0f; char g_szFileName[MAX_PATH]; -ID3DXEffect* g_piDefaultEffect = NULL; -ID3DXEffect* g_piNormalsEffect = NULL; -ID3DXEffect* g_piPassThroughEffect = NULL; -ID3DXEffect* g_piPatternEffect = NULL; +ID3DXEffect* g_piDefaultEffect = nullptr; +ID3DXEffect* g_piNormalsEffect = nullptr; +ID3DXEffect* g_piPassThroughEffect = nullptr; +ID3DXEffect* g_piPatternEffect = nullptr; bool g_bMousePressed = false; bool g_bMousePressedR = false; bool g_bMousePressedM = false; @@ -79,10 +79,10 @@ bool g_bMousePressedBoth = false; float g_fElpasedTime = 0.0f; D3DCAPS9 g_sCaps; bool g_bLoadingFinished = false; -HANDLE g_hThreadHandle = NULL; +HANDLE g_hThreadHandle = nullptr; float g_fWheelPos = -10.0f; bool g_bLoadingCanceled = false; -IDirect3DTexture9* g_pcTexture = NULL; +IDirect3DTexture9* g_pcTexture = nullptr; bool g_bPlay = false; double g_dCurrent = 0.; @@ -135,13 +135,13 @@ float g_fLightColor = 1.0f; RenderOptions g_sOptions; Camera g_sCamera; -AssetHelper *g_pcAsset = NULL; +AssetHelper *g_pcAsset = nullptr; // // Contains the mask image for the HUD // (used to determine the position of a click) // -unsigned char* g_szImageMask = NULL; +unsigned char* g_szImageMask = nullptr; float g_fLoadTime = 0.0f; @@ -175,7 +175,7 @@ DWORD WINAPI LoadThreadProc(LPVOID lpParameter) aiProcess_ConvertToLeftHanded | // convert everything to D3D left handed space aiProcess_SortByPType | // make 'clean' meshes which consist of a single typ of primitives 0, - NULL, + nullptr, props); aiReleasePropertyStore(props); @@ -186,7 +186,7 @@ DWORD WINAPI LoadThreadProc(LPVOID lpParameter) g_bLoadingFinished = true; // check whether the loading process has failed ... - if (NULL == g_pcAsset->pcScene) + if (nullptr == g_pcAsset->pcScene) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to load this asset:", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); @@ -223,7 +223,7 @@ int LoadAsset() DWORD dwID; g_bLoadingCanceled = false; g_pcAsset = new AssetHelper(); - g_hThreadHandle = CreateThread(NULL,0,&LoadThreadProc,NULL,0,&dwID); + g_hThreadHandle = CreateThread(nullptr,0,&LoadThreadProc,nullptr,0,&dwID); if (!g_hThreadHandle) { @@ -248,7 +248,7 @@ int LoadAsset() if (g_pcAsset) { delete g_pcAsset; - g_pcAsset = NULL; + g_pcAsset = nullptr; } return 0; } @@ -328,7 +328,7 @@ int DeleteAsset(void) { delete[] g_pcAsset->apcMeshes; delete g_pcAsset->mAnimator; delete g_pcAsset; - g_pcAsset = NULL; + g_pcAsset = nullptr; // reset the caption of the viewer window SetWindowText(g_hDlg,AI_VIEW_CAPTION_BASE); @@ -351,8 +351,8 @@ int DeleteAsset(void) { // piMatrix Transformation matrix of the graph at this position //------------------------------------------------------------------------------- int CalculateBounds(aiNode* piNode, aiVector3D* p_avOut, const aiMatrix4x4& piMatrix) { - ai_assert(NULL != piNode); - ai_assert(NULL != p_avOut); + ai_assert(nullptr != piNode); + ai_assert(nullptr != p_avOut); aiMatrix4x4 mTemp = piNode->mTransformation; mTemp.Transpose(); @@ -424,8 +424,8 @@ int ScaleAsset(void) //------------------------------------------------------------------------------- int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource) { - ai_assert(NULL != pcMesh); - ai_assert(NULL != pcSource); + ai_assert(nullptr != pcMesh); + ai_assert(nullptr != pcSource); if (!pcSource->mNormals)return 0; @@ -434,7 +434,7 @@ int GenerateNormalsAsLineList(AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSo pcSource->mNumVertices * 2, D3DUSAGE_WRITEONLY, AssetHelper::LineVertex::GetFVF(), - D3DPOOL_DEFAULT, &pcMesh->piVBNormals,NULL))) + D3DPOOL_DEFAULT, &pcMesh->piVBNormals,nullptr))) { CLogDisplay::Instance().AddEntry("Failed to create vertex buffer for the normal list", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); @@ -495,7 +495,7 @@ int CreateAssetData() mesh->mNumVertices, D3DUSAGE_WRITEONLY, 0, - D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piVB,NULL))) { + D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piVB,nullptr))) { MessageBox(g_hDlg,"Failed to create vertex buffer", "ASSIMP Viewer Utility",MB_OK); return 2; @@ -505,7 +505,7 @@ int CreateAssetData() if (g_pcAsset->apcMeshes[i]->piOpacityTexture || 1.0f != g_pcAsset->apcMeshes[i]->fOpacity) dwUsage |= D3DUSAGE_DYNAMIC; - unsigned int nidx; + unsigned int nidx = 0; switch (mesh->mPrimitiveTypes) { case aiPrimitiveType_POINT: nidx = 1; @@ -534,7 +534,7 @@ int CreateAssetData() D3DFMT_INDEX32, D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piIB, - NULL))) + nullptr))) { MessageBox(g_hDlg,"Failed to create 32 Bit index buffer", "ASSIMP Viewer Utility",MB_OK); @@ -560,7 +560,7 @@ int CreateAssetData() D3DFMT_INDEX16, D3DPOOL_DEFAULT, &g_pcAsset->apcMeshes[i]->piIB, - NULL))) + nullptr))) { MessageBox(g_hDlg,"Failed to create 16 Bit index buffer", "ASSIMP Viewer Utility",MB_OK); @@ -595,11 +595,11 @@ int CreateAssetData() { pbData2->vPosition = mesh->mVertices[x]; - if (NULL == mesh->mNormals) + if (nullptr == mesh->mNormals) pbData2->vNormal = aiVector3D(0.0f,0.0f,0.0f); else pbData2->vNormal = mesh->mNormals[x]; - if (NULL == mesh->mTangents) { + if (nullptr == mesh->mTangents) { pbData2->vTangent = aiVector3D(0.0f,0.0f,0.0f); pbData2->vBitangent = aiVector3D(0.0f,0.0f,0.0f); } @@ -639,7 +639,7 @@ int CreateAssetData() ai_assert( weightsPerVertex[x].size() <= 4); for( unsigned int a = 0; a < weightsPerVertex[x].size(); a++) { - boneIndices[a] = weightsPerVertex[x][a].mVertexId; + boneIndices[a] = static_cast(weightsPerVertex[x][a].mVertexId); boneWeights[a] = (unsigned char) (weightsPerVertex[x][a].mWeight * 255.0f); } @@ -677,17 +677,17 @@ int DeleteAssetData(bool bNoMaterials) if(g_pcAsset->apcMeshes[i]->piVB) { g_pcAsset->apcMeshes[i]->piVB->Release(); - g_pcAsset->apcMeshes[i]->piVB = NULL; + g_pcAsset->apcMeshes[i]->piVB = nullptr; } if(g_pcAsset->apcMeshes[i]->piVBNormals) { g_pcAsset->apcMeshes[i]->piVBNormals->Release(); - g_pcAsset->apcMeshes[i]->piVBNormals = NULL; + g_pcAsset->apcMeshes[i]->piVBNormals = nullptr; } if(g_pcAsset->apcMeshes[i]->piIB) { g_pcAsset->apcMeshes[i]->piIB->Release(); - g_pcAsset->apcMeshes[i]->piIB = NULL; + g_pcAsset->apcMeshes[i]->piIB = nullptr; } // TODO ... unfixed memory leak @@ -703,42 +703,42 @@ int DeleteAssetData(bool bNoMaterials) if(g_pcAsset->apcMeshes[i]->piEffect) { g_pcAsset->apcMeshes[i]->piEffect->Release(); - g_pcAsset->apcMeshes[i]->piEffect = NULL; + g_pcAsset->apcMeshes[i]->piEffect = nullptr; } if(g_pcAsset->apcMeshes[i]->piDiffuseTexture) { g_pcAsset->apcMeshes[i]->piDiffuseTexture->Release(); - g_pcAsset->apcMeshes[i]->piDiffuseTexture = NULL; + g_pcAsset->apcMeshes[i]->piDiffuseTexture = nullptr; } if(g_pcAsset->apcMeshes[i]->piNormalTexture) { g_pcAsset->apcMeshes[i]->piNormalTexture->Release(); - g_pcAsset->apcMeshes[i]->piNormalTexture = NULL; + g_pcAsset->apcMeshes[i]->piNormalTexture = nullptr; } if(g_pcAsset->apcMeshes[i]->piSpecularTexture) { g_pcAsset->apcMeshes[i]->piSpecularTexture->Release(); - g_pcAsset->apcMeshes[i]->piSpecularTexture = NULL; + g_pcAsset->apcMeshes[i]->piSpecularTexture = nullptr; } if(g_pcAsset->apcMeshes[i]->piAmbientTexture) { g_pcAsset->apcMeshes[i]->piAmbientTexture->Release(); - g_pcAsset->apcMeshes[i]->piAmbientTexture = NULL; + g_pcAsset->apcMeshes[i]->piAmbientTexture = nullptr; } if(g_pcAsset->apcMeshes[i]->piEmissiveTexture) { g_pcAsset->apcMeshes[i]->piEmissiveTexture->Release(); - g_pcAsset->apcMeshes[i]->piEmissiveTexture = NULL; + g_pcAsset->apcMeshes[i]->piEmissiveTexture = nullptr; } if(g_pcAsset->apcMeshes[i]->piOpacityTexture) { g_pcAsset->apcMeshes[i]->piOpacityTexture->Release(); - g_pcAsset->apcMeshes[i]->piOpacityTexture = NULL; + g_pcAsset->apcMeshes[i]->piOpacityTexture = nullptr; } if(g_pcAsset->apcMeshes[i]->piShininessTexture) { g_pcAsset->apcMeshes[i]->piShininessTexture->Release(); - g_pcAsset->apcMeshes[i]->piShininessTexture = NULL; + g_pcAsset->apcMeshes[i]->piShininessTexture = nullptr; } } } @@ -776,10 +776,10 @@ int SetupFPSView() //------------------------------------------------------------------------------- int InitD3D(void) { - if (NULL == g_piD3D) + if (nullptr == g_piD3D) { g_piD3D = Direct3DCreate9(D3D_SDK_VERSION); - if (NULL == g_piD3D)return 0; + if (nullptr == g_piD3D)return 0; } return 1; } @@ -792,20 +792,20 @@ int InitD3D(void) int ShutdownD3D(void) { ShutdownDevice(); - if (NULL != g_piD3D) + if (nullptr != g_piD3D) { g_piD3D->Release(); - g_piD3D = NULL; + g_piD3D = nullptr; } return 1; } template inline -void SafeRelease(TComPtr *ptr) { - if (nullptr != g_piPassThroughEffect) { - g_piPassThroughEffect->Release(); - g_piPassThroughEffect = nullptr; +void SafeRelease(TComPtr *&ptr) { + if (nullptr != ptr) { + ptr->Release(); + ptr = nullptr; } } @@ -843,12 +843,12 @@ int ShutdownDevice(void) int CreateHUDTexture() { // lock the memory resource ourselves - HRSRC res = FindResource(NULL,MAKEINTRESOURCE(IDR_HUD),RT_RCDATA); - HGLOBAL hg = LoadResource(NULL,res); + HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUD),RT_RCDATA); + HGLOBAL hg = LoadResource(nullptr,res); void* pData = LockResource(hg); if(FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice, - pData,SizeofResource(NULL,res), + pData,SizeofResource(nullptr,res), D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2, 1, @@ -858,15 +858,15 @@ int CreateHUDTexture() D3DX_DEFAULT, D3DX_DEFAULT, 0, - NULL, - NULL, + nullptr, + nullptr, &g_pcTexture))) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD texture", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); - g_pcTexture = NULL; - g_szImageMask = NULL; + g_pcTexture = nullptr; + g_szImageMask = nullptr; FreeResource(hg); return 0; @@ -879,13 +879,13 @@ int CreateHUDTexture() // lock the memory resource ourselves - res = FindResource(NULL,MAKEINTRESOURCE(IDR_HUDMASK),RT_RCDATA); - hg = LoadResource(NULL,res); + res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUDMASK),RT_RCDATA); + hg = LoadResource(nullptr,res); pData = LockResource(hg); IDirect3DTexture9* pcTex; if(FAILED(D3DXCreateTextureFromFileInMemoryEx(g_piDevice, - pData,SizeofResource(NULL,res), + pData,SizeofResource(nullptr,res), sDesc.Width, sDesc.Height, 1, @@ -895,13 +895,13 @@ int CreateHUDTexture() D3DX_DEFAULT, D3DX_DEFAULT, 0, - NULL, - NULL, + nullptr, + nullptr, &pcTex))) { CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD mask texture", D3DCOLOR_ARGB(0xFF,0xFF,0,0)); - g_szImageMask = NULL; + g_szImageMask = nullptr; FreeResource(hg); return 0; @@ -911,7 +911,7 @@ int CreateHUDTexture() // lock the texture and copy it to get a pointer D3DLOCKED_RECT sRect; - pcTex->LockRect(0,&sRect,NULL,D3DLOCK_READONLY); + pcTex->LockRect(0,&sRect,nullptr,D3DLOCK_READONLY); unsigned char* szOut = new unsigned char[sDesc.Width * sDesc.Height]; unsigned char* _szOut = szOut; @@ -1023,14 +1023,14 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/) } // compile the default material shader (gray gouraud/phong) - ID3DXBuffer* piBuffer = NULL; + ID3DXBuffer* piBuffer = nullptr; if(FAILED( D3DXCreateEffect(g_piDevice, g_szDefaultShader.c_str(), (UINT)g_szDefaultShader.length(), - NULL, - NULL, + nullptr, + nullptr, AI_SHADER_COMPILE_FLAGS, - NULL, + nullptr, &g_piDefaultEffect,&piBuffer))) { if( piBuffer) @@ -1043,7 +1043,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/) if( piBuffer) { piBuffer->Release(); - piBuffer = NULL; + piBuffer = nullptr; } // use Fixed Function effect when working with shaderless cards @@ -1053,7 +1053,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/) // create the shader used to draw the HUD if(FAILED( D3DXCreateEffect(g_piDevice, g_szPassThroughShader.c_str(),(UINT)g_szPassThroughShader.length(), - NULL,NULL,AI_SHADER_COMPILE_FLAGS,NULL,&g_piPassThroughEffect,&piBuffer))) + nullptr,nullptr,AI_SHADER_COMPILE_FLAGS,nullptr,&g_piPassThroughEffect,&piBuffer))) { if( piBuffer) { @@ -1065,7 +1065,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/) if( piBuffer) { piBuffer->Release(); - piBuffer = NULL; + piBuffer = nullptr; } // use Fixed Function effect when working with shaderless cards @@ -1075,7 +1075,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/) // create the shader used to visualize normal vectors if(FAILED( D3DXCreateEffect(g_piDevice, g_szNormalsShader.c_str(),(UINT)g_szNormalsShader.length(), - NULL,NULL,AI_SHADER_COMPILE_FLAGS,NULL,&g_piNormalsEffect, &piBuffer))) + nullptr,nullptr,AI_SHADER_COMPILE_FLAGS,nullptr,&g_piNormalsEffect, &piBuffer))) { if( piBuffer) { @@ -1087,7 +1087,7 @@ int CreateDevice (bool p_bMultiSample,bool p_bSuperSample,bool bHW /*= true*/) if( piBuffer) { piBuffer->Release(); - piBuffer = NULL; + piBuffer = nullptr; } //MessageBox( g_hDlg, "Failed to create vertex declaration", "Init", MB_OK);