Merge branch 'master' into sample-simpleopengl-minor-improvements

.github/FUNDING.yml

@@ -1,2 +1,2 @@
 patreon: assimp
-Paypal: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4JRJVPXC4QJM4
+custom: https://www.paypal.com/cgi-bin/webscr?cmd=_s-xclick&hosted_button_id=4JRJVPXC4QJM4

.github/workflows/ccpp.yml

@@ -7,12 +7,11 @@ on:
     branches: [ master ]
 
 jobs:
-  build-ubuntu:
+  linux:
-
     runs-on: ubuntu-latest
     
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
     - name: configure
       run: cmake CMakeLists.txt
     - name: build
@@ -20,3 +19,28 @@ jobs:
     - name: test
       run: cd bin && ./unit
   
+  mac:
+    runs-on: macos-latest
+    
+    steps:
+    - uses: actions/checkout@v2
+    - name: configure
+      run: cmake CMakeLists.txt
+    - name: build
+      run: cmake --build .
+    - name: test
+      run: cd bin && ./unit
+
+  windows:
+    runs-on: windows-latest
+    
+    steps:
+    - uses: actions/checkout@v2
+    - name: configure
+      run: cmake CMakeLists.txt
+    - name: build
+      run: cmake --build . --config Release
+    - name: test
+      run: | 
+        cd bin\Release
+        .\unit

CMakeLists.txt

@@ -39,9 +39,9 @@ SET(CMAKE_POLICY_DEFAULT_CMP0074 NEW)
 CMAKE_MINIMUM_REQUIRED( VERSION 3.0 )
 
 # Toggles the use of the hunter package manager
-option(HUNTER_ENABLED "Enable Hunter package manager support" OFF)
+option(ASSIMP_HUNTER_ENABLED "Enable Hunter package manager support" OFF)
 
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   include("cmake/HunterGate.cmake")
   HunterGate(
     URL "https://github.com/ruslo/hunter/archive/v0.23.176.tar.gz"
@@ -60,7 +60,7 @@ OPTION( BUILD_SHARED_LIBS
   ON
 )
 
-OPTION( BUILD_FRAMEWORK
+OPTION( ASSIMP_BUILD_FRAMEWORK
   "Build package as Mac OS X Framework bundle."
   OFF
 )
@@ -101,7 +101,7 @@ OPTION ( ASSIMP_COVERALLS
   OFF
 )
 OPTION( ASSIMP_INSTALL
-  "DIsable this if you want to use assimp as a submodule."
+  "Disable this if you want to use assimp as a submodule."
   ON
 )
 OPTION ( ASSIMP_ERROR_MAX
@@ -120,25 +120,25 @@ OPTION ( ASSIMP_UBSAN
   "Enable Undefined Behavior sanitizer."
   OFF
 )
-OPTION ( SYSTEM_IRRXML
+OPTION ( ASSIMP_SYSTEM_IRRXML
   "Use system installed Irrlicht/IrrXML library."
   OFF
 )
-OPTION ( BUILD_DOCS
+OPTION ( ASSIMP_BUILD_DOCS
   "Build documentation using Doxygen."
   OFF
 )
-OPTION( INJECT_DEBUG_POSTFIX
+OPTION( ASSIMP_INJECT_DEBUG_POSTFIX
   "Inject debug postfix in .a/.so/.dll lib names"
   ON
 )
 
-OPTION ( IGNORE_GIT_HASH
+OPTION ( ASSIMP_IGNORE_GIT_HASH
    "Don't call git to get the hash."
    OFF
 )
 
-IF (IOS AND NOT HUNTER_ENABLED)
+IF (IOS AND NOT ASSIMP_HUNTER_ENABLED)
   IF (NOT CMAKE_BUILD_TYPE)
     SET(CMAKE_BUILD_TYPE "Release")
   ENDIF ()
@@ -161,7 +161,7 @@ IF(MSVC)
   ENDIF()
 ENDIF()
 
-IF (BUILD_FRAMEWORK)
+IF (ASSIMP_BUILD_FRAMEWORK)
   SET (BUILD_SHARED_LIBS ON)
   MESSAGE(STATUS "Framework bundle building enabled")
 ENDIF()
@@ -181,12 +181,12 @@ SET (ASSIMP_VERSION ${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VER
 SET (ASSIMP_SOVERSION 5)
 
 SET( ASSIMP_PACKAGE_VERSION "0" CACHE STRING "the package-specific version used for uploading the sources" )
-if(NOT HUNTER_ENABLED)
+if(NOT ASSIMP_HUNTER_ENABLED)
   # Enable C++11 support globally
   set_property( GLOBAL PROPERTY CXX_STANDARD 11 )
 endif()
 
-IF(NOT IGNORE_GIT_HASH)
+IF(NOT ASSIMP_IGNORE_GIT_HASH)
   # Get the current working branch
   EXECUTE_PROCESS(
     COMMAND git rev-parse --abbrev-ref HEAD
@@ -238,14 +238,9 @@ 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 HUNTER_ENABLED)
+  IF(NOT ASSIMP_HUNTER_ENABLED)
     SET(CMAKE_CXX_FLAGS "-fPIC -std=c++0x ${CMAKE_CXX_FLAGS}")
     SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}")
   ENDIF()
@@ -262,7 +257,7 @@ ELSEIF(MSVC)
   ENDIF()
   SET(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} /D_DEBUG /Zi /Od")
 ELSEIF ( "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang" )
-  IF(NOT HUNTER_ENABLED)
+  IF(NOT ASSIMP_HUNTER_ENABLED)
     SET(CMAKE_CXX_FLAGS "-fPIC -std=c++11 ${CMAKE_CXX_FLAGS}")
     SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}")
   ENDIF()
@@ -274,7 +269,7 @@ ELSEIF( CMAKE_COMPILER_IS_MINGW )
   ELSEIF(CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.3)
     message(WARNING "MinGW is old, if you experience errors, update MinGW.")
   ENDIF()
-  IF(NOT HUNTER_ENABLED)
+  IF(NOT ASSIMP_HUNTER_ENABLED)
     SET(CMAKE_CXX_FLAGS "-std=c++11 ${CMAKE_CXX_FLAGS}")
     SET(CMAKE_C_FLAGS "-fPIC ${CMAKE_C_FLAGS}")
   ENDIF()
@@ -283,7 +278,7 @@ ELSEIF( CMAKE_COMPILER_IS_MINGW )
   ADD_DEFINITIONS( -U__STRICT_ANSI__ )
 ENDIF()
 
-IF ( IOS AND NOT HUNTER_ENABLED)
+IF ( IOS AND NOT ASSIMP_HUNTER_ENABLED)
   IF (CMAKE_BUILD_TYPE STREQUAL "Debug")
     SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fembed-bitcode -Og")
     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fembed-bitcode -Og")
@@ -350,17 +345,9 @@ 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 (INJECT_DEBUG_POSTFIX AND (is_multi_config OR CMAKE_BUILD_TYPE STREQUAL "Debug"))
+IF (ASSIMP_INJECT_DEBUG_POSTFIX AND (is_multi_config OR CMAKE_BUILD_TYPE STREQUAL "Debug"))
   SET(CMAKE_DEBUG_POSTFIX "d" CACHE STRING "Debug Postfix for lib, samples and tools")
 ELSE()
   SET(CMAKE_DEBUG_POSTFIX "" CACHE STRING "Debug Postfix for lib, samples and tools")
@@ -373,7 +360,7 @@ IF (NOT TARGET uninstall)
   ADD_CUSTOM_TARGET(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 ENDIF()
 
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   set(CONFIG_INSTALL_DIR "lib/cmake/${PROJECT_NAME}")
   set(INCLUDE_INSTALL_DIR "include")
 
@@ -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)
@@ -440,18 +449,18 @@ ELSE()
     DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT})
 ENDIF()
 
-IF( BUILD_DOCS )
+IF( ASSIMP_BUILD_DOCS )
   ADD_SUBDIRECTORY(doc)
 ENDIF()
 
 # Look for system installed irrXML
-IF ( SYSTEM_IRRXML )
+IF ( ASSIMP_SYSTEM_IRRXML )
   FIND_PACKAGE( IrrXML REQUIRED )
 ENDIF()
 
 # Search for external dependencies, and build them from source if not found
 # Search for zlib
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(ZLIB)
   find_package(ZLIB CONFIG REQUIRED)
 
@@ -575,7 +584,7 @@ ELSE ()
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
 ENDIF ()
 
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   ADD_SUBDIRECTORY(contrib)
 ENDIF()
 

assimp.pc.in

@@ -1,7 +1,5 @@
-prefix=@CMAKE_INSTALL_PREFIX@
+libdir=@CMAKE_INSTALL_FULL_LIBDIR@
-exec_prefix=@CMAKE_INSTALL_PREFIX@/
+includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
-libdir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_LIB_INSTALL_DIR@
-includedir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_INCLUDE_INSTALL_DIR@
 
 Name: @CMAKE_PROJECT_NAME@
 Description: Import various well-known 3D model formats in an uniform manner.

assimpTargets-debug.cmake.in

@@ -7,6 +7,14 @@ set(CMAKE_IMPORT_FILE_VERSION 1)
 
 set(ASSIMP_BUILD_SHARED_LIBS @BUILD_SHARED_LIBS@)
 
+get_property(LIB64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS)
+
+if ("${LIB64}" STREQUAL "TRUE")
+    set(LIBSUFFIX 64)
+else()
+    set(LIBSUFFIX "")
+endif()
+
 if(MSVC)
   if(MSVC_TOOLSET_VERSION)
     set(MSVC_PREFIX "vc${MSVC_TOOLSET_VERSION}")
@@ -44,22 +52,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_IMPLIB_DEBUG "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}"
-      IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/bin/${sharedLibraryName}"
+      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 "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}")
-    list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" )
+    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,23 +83,20 @@ else()
     endif()
     set_target_properties(assimp::assimp PROPERTIES
       IMPORTED_SONAME_DEBUG "${sharedLibraryName}"
-      IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib/${sharedLibraryName}"
+      IMPORTED_LOCATION_DEBUG "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${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 "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${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 "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${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 "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${staticLibraryName}" )
   endif()
 endif()
 
-
-
-
 # Commands beyond this point should not need to know the version.
 set(CMAKE_IMPORT_FILE_VERSION)
 

assimpTargets-release.cmake.in

@@ -7,6 +7,14 @@ set(CMAKE_IMPORT_FILE_VERSION 1)
 
 set(ASSIMP_BUILD_SHARED_LIBS @BUILD_SHARED_LIBS@)
 
+get_property(LIB64 GLOBAL PROPERTY FIND_LIBRARY_USE_LIB64_PATHS)
+
+if ("${LIB64}" STREQUAL "TRUE")
+    set(LIBSUFFIX 64)
+else()
+    set(LIBSUFFIX "")
+endif()
+
 if(MSVC)
   if(MSVC_TOOLSET_VERSION)
     set(MSVC_PREFIX "vc${MSVC_TOOLSET_VERSION}")
@@ -44,12 +52,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_IMPLIB_RELEASE "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}"
-      IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/bin/${sharedLibraryName}"
+      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 "@CMAKE_INSTALL_FULL_LIBDIR@/${importLibraryName}")
-    list(APPEND _IMPORT_CHECK_FILES_FOR_assimp::assimp "${_IMPORT_PREFIX}/bin/${sharedLibraryName}" )
+    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 +67,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 +83,17 @@ else()
     endif()
     set_target_properties(assimp::assimp PROPERTIES
       IMPORTED_SONAME_RELEASE "${sharedLibraryName}"
-
+      IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${sharedLibraryName}"
-      IMPORTED_LOCATION_RELEASE "${_IMPORT_PREFIX}/lib/${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 "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${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 "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${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 "${_IMPORT_PREFIX}/lib${LIBSUFFIX}/${staticLibraryName}" )
   endif()
 endif()
 

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}} )

code/3DS/3DSConverter.cpp

@@ -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,
@@ -43,7 +41,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the 3ds importer class */
 
-
 #ifndef ASSIMP_BUILD_NO_3DS_IMPORTER
 
 // internal headers

code/3DS/3DSHelper.h

@@ -441,12 +441,33 @@ struct Material {
         // empty
     }
 
-    Material(const Material &other) = default;
+    Material(const Material &other) :
-    Material &operator=(const Material &other) = default;
+            mName(other.mName),
+            mDiffuse(other.mDiffuse),
+            mSpecularExponent(other.mSpecularExponent),
+            mShininessStrength(other.mShininessStrength),
+            mSpecular(other.mSpecular),
+            mAmbient(other.mAmbient),
+            mShading(other.mShading),
+            mTransparency(other.mTransparency),
+            sTexDiffuse(other.sTexDiffuse),
+            sTexOpacity(other.sTexOpacity),
+            sTexSpecular(other.sTexSpecular),
+            sTexReflective(other.sTexReflective),
+            sTexBump(other.sTexBump),
+            sTexEmissive(other.sTexEmissive),
+            sTexShininess(other.sTexShininess),
+            mBumpHeight(other.mBumpHeight),
+            mEmissive(other.mEmissive),
+            sTexAmbient(other.sTexAmbient),
+            mTwoSided(other.mTwoSided) {
+        // empty
+
+    }
 
     //! Move constructor. This is explicitly written because MSVC doesn't support defaulting it
-    Material(Material &&other) AI_NO_EXCEPT
+    Material(Material &&other) AI_NO_EXCEPT :
-            : mName(std::move(other.mName)),
+            mName(std::move(other.mName)),
             mDiffuse(std::move(other.mDiffuse)),
             mSpecularExponent(std::move(other.mSpecularExponent)),
             mShininessStrength(std::move(other.mShininessStrength)),
@@ -465,6 +486,7 @@ struct Material {
             mEmissive(std::move(other.mEmissive)),
             sTexAmbient(std::move(other.sTexAmbient)),
             mTwoSided(std::move(other.mTwoSided)) {
+        // empty
     }
 
     Material &operator=(Material &&other) AI_NO_EXCEPT {

code/3DS/3DSLoader.cpp

@@ -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,
@@ -72,7 +70,6 @@ static const aiImporterDesc desc = {
 	"3ds prj"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Begins a new parsing block
 // - Reads the current chunk and validates it
@@ -141,15 +138,13 @@ bool Discreet3DSImporter::CanRead( const std::string& pFile, IOSystem* pIOHandle
 
 // ------------------------------------------------------------------------------------------------
 // Loader registry entry
-const aiImporterDesc* Discreet3DSImporter::GetInfo () const
+const aiImporterDesc* Discreet3DSImporter::GetInfo () const {
-{
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties
-void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/)
+void Discreet3DSImporter::SetupProperties(const Importer* /*pImp*/) {
-{
     // nothing to be done for the moment
 }
 
@@ -200,7 +195,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
         ComputeNormalsWithSmoothingsGroups<D3DS::Face>(mesh);
     }
 
-    // Replace all occurences of the default material with a
+    // Replace all occurrences of the default material with a
     // valid material. Generate it if no material containing
     // DEFAULT in its name has been found in the file
     ReplaceDefaultMaterial();
@@ -227,8 +222,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
 
 // ------------------------------------------------------------------------------------------------
 // Applies a master-scaling factor to the imported scene
-void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene)
+void Discreet3DSImporter::ApplyMasterScale(aiScene* pScene) {
-{
     // There are some 3DS files with a zero scaling factor
     if (!mMasterScale)mMasterScale = 1.0f;
     else mMasterScale = 1.0f / mMasterScale;
@@ -1084,7 +1078,7 @@ void Discreet3DSImporter::ParseMeshChunk()
         mMesh.mFaceMaterials.resize(mMesh.mFaces.size(),0xcdcdcdcd);
 
         // Larger 3DS files could have multiple FACE chunks here
-        chunkSize = stream->GetRemainingSizeToLimit();
+        chunkSize = (int)stream->GetRemainingSizeToLimit();
         if ( chunkSize > (int) sizeof(Discreet3DS::Chunk ) )
             ParseFaceChunk();
         }

code/3DS/3DSLoader.h

@@ -65,15 +65,11 @@ using namespace D3DS;
 // ---------------------------------------------------------------------------------
 /** Importer class for 3D Studio r3 and r4 3DS files
  */
-class Discreet3DSImporter : public BaseImporter
+class Discreet3DSImporter : public BaseImporter {
-{
 public:
-
     Discreet3DSImporter();
     ~Discreet3DSImporter();
 
-public:
-
     // -------------------------------------------------------------------
     /** Returns whether the class can handle the format of the given file.
      * See BaseImporter::CanRead() for details.

code/Assjson/cencode.c

@@ -9,6 +9,9 @@ For details, see http://sourceforge.net/projects/libb64
 
 const int CHARS_PER_LINE = 72;
 
+#pragma warning(push)
+#pragma warning(disable : 4244)
+
 void base64_init_encodestate(base64_encodestate* state_in)
 {
 	state_in->step = step_A;
@@ -107,3 +110,4 @@ int base64_encode_blockend(char* code_out, base64_encodestate* state_in)
 	return (int)(codechar - code_out);
 }
 
+#pragma warning(pop)

code/Blender/BlenderLoader.cpp

@@ -206,7 +206,7 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
         inflateInit2(&zstream, 16+MAX_WBITS);
 
         zstream.next_in   = reinterpret_cast<Bytef*>( reader->GetPtr() );
-        zstream.avail_in  = reader->GetRemainingSize();
+        zstream.avail_in  = (uInt) reader->GetRemainingSize();
 
         size_t total = 0l;
 

code/CMakeLists.txt

@@ -886,7 +886,7 @@ SET( Extra_SRCS
 SOURCE_GROUP( Extra FILES ${Extra_SRCS})
 
 # irrXML
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(irrXML)
   find_package(irrXML CONFIG REQUIRED)
 ELSE()
@@ -894,7 +894,7 @@ ELSE()
 ENDIF()
 
 # utf8
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(utf8)
   find_package(utf8 CONFIG REQUIRED)
 ELSE()
@@ -902,7 +902,7 @@ ELSE()
 ENDIF()
 
 # polyclipping
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(polyclipping)
   find_package(polyclipping CONFIG REQUIRED)
 ELSE()
@@ -914,7 +914,7 @@ ELSE()
 ENDIF()
 
 # poly2tri
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(poly2tri)
   find_package(poly2tri CONFIG REQUIRED)
 ELSE()
@@ -935,7 +935,7 @@ ELSE()
 ENDIF()
 
 # minizip/unzip
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(minizip)
   find_package(minizip CONFIG REQUIRED)
 ELSE()
@@ -950,7 +950,7 @@ ELSE()
 ENDIF()
 
 # zip (https://github.com/kuba--/zip)
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(zip)
   find_package(zip CONFIG REQUIRED)
 ELSE()
@@ -971,7 +971,7 @@ ELSE()
 ENDIF()
 
 # openddlparser
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(openddlparser)
   find_package(openddlparser CONFIG REQUIRED)
 ELSE()
@@ -994,7 +994,7 @@ ELSE()
 ENDIF()
 
 # Open3DGC
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   # Nothing to do, not available in Hunter yet.
 ELSE()
   SET ( open3dgc_SRCS
@@ -1035,7 +1035,7 @@ ENDIF()
 # RT-extensions is used in "contrib/Open3DGC/o3dgcTimer.h" for collecting statistics. Pointed file
 # has implementation for different platforms: WIN32, __MACH__ and other ("else" block).
 FIND_PACKAGE(RT QUIET)
-IF (NOT HUNTER_ENABLED AND (RT_FOUND OR MSVC))
+IF (NOT ASSIMP_HUNTER_ENABLED AND (RT_FOUND OR MSVC))
   SET( ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC 1 )
   ADD_DEFINITIONS( -DASSIMP_IMPORTER_GLTF_USE_OPEN3DGC=1 )
 ELSE ()
@@ -1045,7 +1045,7 @@ ELSE ()
 ENDIF ()
 
 # RapidJSON
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   hunter_add_package(RapidJSON)
   find_package(RapidJSON CONFIG REQUIRED)
 ELSE()
@@ -1068,7 +1068,7 @@ if ( MSVC )
   ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
 endif ()
 
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   if (UNZIP_FOUND)
     SET (unzip_compile_SRCS "")
   else ()
@@ -1118,7 +1118,7 @@ SET( assimp_src
 )
 ADD_DEFINITIONS( -DOPENDDLPARSER_BUILD )
 
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   INCLUDE_DIRECTORIES(
       ${IRRXML_INCLUDE_DIR}
       ../contrib/openddlparser/include
@@ -1139,7 +1139,7 @@ TARGET_INCLUDE_DIRECTORIES ( assimp PUBLIC
   $<INSTALL_INTERFACE:include>
 )
 
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   TARGET_LINK_LIBRARIES(assimp
       PUBLIC
       polyclipping::polyclipping
@@ -1212,7 +1212,7 @@ SET_TARGET_PROPERTIES( assimp PROPERTIES
 )
 
 if (APPLE)
-  if (BUILD_FRAMEWORK)
+  if (ASSIMP_BUILD_FRAMEWORK)
     SET_TARGET_PROPERTIES( assimp PROPERTIES
       FRAMEWORK TRUE
       FRAMEWORK_VERSION C
@@ -1232,7 +1232,7 @@ ENDIF()
 
 # Build against external unzip, or add ../contrib/unzip so
 # assimp can #include "unzip.h"
-IF(NOT HUNTER_ENABLED)
+IF(NOT ASSIMP_HUNTER_ENABLED)
   if (UNZIP_FOUND)
     INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS})
     TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES})
@@ -1246,7 +1246,7 @@ IF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
   TARGET_LINK_LIBRARIES(assimp ${RT_LIBRARY})
 ENDIF ()
 
-IF(HUNTER_ENABLED)
+IF(ASSIMP_HUNTER_ENABLED)
   INSTALL( TARGETS assimp
     EXPORT "${TARGETS_EXPORT_NAME}"
     LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}

code/CSM/CSMLoader.cpp

@@ -178,7 +178,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                         *ot++ = *buffer++;
 
                     *ot = '\0';
-                    nda->mNodeName.length = (ai_uint32)(ot-nda->mNodeName.data);
+                    nda->mNodeName.length = static_cast<ai_uint32>(ot-nda->mNodeName.data);
                 }
 
                 anim->mNumChannels = static_cast<unsigned int>(anims_temp.size());

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 <assimp/BaseImporter.h>
+#include <assimp/Exceptional.h>
+#include <assimp/GenericProperty.h>
 #include <assimp/cimport.h>
-#include <assimp/LogStream.hpp>
-#include <assimp/DefaultLogger.hpp>
-#include <assimp/Importer.hpp>
 #include <assimp/importerdesc.h>
 #include <assimp/scene.h>
-#include <assimp/GenericProperty.h>
+#include <assimp/DefaultLogger.hpp>
-#include <assimp/Exceptional.h>
+#include <assimp/Importer.hpp>
-#include <assimp/BaseImporter.h>
+#include <assimp/LogStream.hpp>
 
 #include "CApi/CInterfaceIOWrapper.h"
 #include "Importer.h"
@@ -62,8 +62,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ------------------------------------------------------------------------------------------------
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#   include <thread>
 #include <mutex>
+#include <thread>
 #endif
 // ------------------------------------------------------------------------------------------------
 using namespace Assimp;
@@ -100,8 +100,7 @@ namespace Assimp {
 
 /** will delete all registered importers. */
 void DeleteImporterInstanceList(std::vector<BaseImporter *> &out);
-} // namespace assimp
+} // namespace Assimp
-
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
 /** Global mutex to manage the access to the log-stream map */
@@ -112,8 +111,8 @@ static std::mutex gLogStreamMutex;
 // Custom LogStream implementation for the C-API
 class LogToCallbackRedirector : public LogStream {
 public:
-    explicit LogToCallbackRedirector(const aiLogStream& s)
+    explicit LogToCallbackRedirector(const aiLogStream &s) :
-    : stream (s)    {
+            stream(s) {
         ai_assert(NULL != s.callback);
     }
 
@@ -212,8 +211,7 @@ const aiScene* aiImportFileFromMemory(
         const char *pBuffer,
         unsigned int pLength,
         unsigned int pFlags,
-    const char* pHint)
+        const char *pHint) {
-{
     return aiImportFileFromMemoryWithProperties(pBuffer, pLength, pFlags, pHint, NULL);
 }
 
@@ -223,8 +221,7 @@ const aiScene* aiImportFileFromMemoryWithProperties(
         unsigned int pLength,
         unsigned int pFlags,
         const char *pHint,
-    const aiPropertyStore* props)
+        const aiPropertyStore *props) {
-{
     ai_assert(NULL != pBuffer);
     ai_assert(0 != pLength);
 
@@ -251,8 +248,7 @@ const aiScene* aiImportFileFromMemoryWithProperties(
     if (scene) {
         ScenePrivateData *priv = const_cast<ScenePrivateData *>(ScenePriv(scene));
         priv->mOrigImporter = imp;
-    }
+    } else {
-    else    {
         // if failed, extract error code and destroy the import
         gLastErrorString = imp->GetErrorString();
         delete imp;
@@ -264,8 +260,7 @@ const aiScene* aiImportFileFromMemoryWithProperties(
 
 // ------------------------------------------------------------------------------------------------
 // Releases all resources associated with the given import process.
-void aiReleaseImport( const aiScene* pScene)
+void aiReleaseImport(const aiScene *pScene) {
-{
     if (!pScene) {
         return;
     }
@@ -276,8 +271,7 @@ void aiReleaseImport( const aiScene* pScene)
     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)
@@ -290,11 +284,9 @@ void aiReleaseImport( const aiScene* pScene)
 
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API const aiScene *aiApplyPostProcessing(const aiScene *pScene,
-    unsigned int pFlags)
+        unsigned int pFlags) {
-{
     const aiScene *sc = NULL;
 
-
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // find the importer associated with this data
@@ -343,8 +335,7 @@ ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene,
 }
 
 // ------------------------------------------------------------------------------------------------
-void CallbackToLogRedirector (const char* msg, char* dt)
+void CallbackToLogRedirector(const char *msg, char *dt) {
-{
     ai_assert(NULL != msg);
     ai_assert(NULL != dt);
     LogStream *s = (LogStream *)dt;
@@ -353,8 +344,7 @@ void CallbackToLogRedirector (const char* msg, char* dt)
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const char* file)
+ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream, const char *file) {
-{
     aiLogStream sout;
 
     ASSIMP_BEGIN_EXCEPTION_REGION();
@@ -362,8 +352,7 @@ ASSIMP_API aiLogStream aiGetPredefinedLogStream(aiDefaultLogStream pStream,const
     if (!stream) {
         sout.callback = NULL;
         sout.user = NULL;
-    }
+    } else {
-    else {
         sout.callback = &CallbackToLogRedirector;
         sout.user = (char *)stream;
     }
@@ -373,8 +362,7 @@ 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
@@ -392,8 +380,7 @@ ASSIMP_API void aiAttachLogStream( const aiLogStream* stream )
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream)
+ASSIMP_API aiReturn aiDetachLogStream(const aiLogStream *stream) {
-{
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
@@ -418,8 +405,7 @@ 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<std::mutex> lock(gLogStreamMutex);
@@ -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,29 +435,25 @@ 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;
     ASSIMP_BEGIN_EXCEPTION_REGION();
@@ -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();
 
@@ -502,8 +482,7 @@ void aiGetExtensionList(aiString* szOut)
 // ------------------------------------------------------------------------------------------------
 // Get the memory requirements for a particular import.
 void aiGetMemoryRequirements(const C_STRUCT aiScene *pIn,
-    C_STRUCT aiMemoryInfo* in)
+        C_STRUCT aiMemoryInfo *in) {
-{
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // find the importer associated with this data
@@ -518,21 +497,18 @@ void aiGetMemoryRequirements(const C_STRUCT aiScene* pIn,
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API aiPropertyStore* aiCreatePropertyStore(void)
+ASSIMP_API aiPropertyStore *aiCreatePropertyStore(void) {
-{
     return reinterpret_cast<aiPropertyStore *>(new PropertyMap());
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API void aiReleasePropertyStore(aiPropertyStore* p)
+ASSIMP_API void aiReleasePropertyStore(aiPropertyStore *p) {
-{
     delete reinterpret_cast<PropertyMap *>(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<PropertyMap *>(p);
     SetGenericProperty<int>(pp->ints, szName, value);
@@ -541,8 +517,7 @@ ASSIMP_API void aiSetImportPropertyInteger(aiPropertyStore* p, const char* szNam
 
 // ------------------------------------------------------------------------------------------------
 // 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<PropertyMap *>(p);
     SetGenericProperty<ai_real>(pp->floats, szName, value);
@@ -552,8 +527,7 @@ ASSIMP_API void aiSetImportPropertyFloat(aiPropertyStore* p, const char* szName,
 // ------------------------------------------------------------------------------------------------
 // Importer::SetPropertyString
 ASSIMP_API void aiSetImportPropertyString(aiPropertyStore *p, const char *szName,
-    const C_STRUCT aiString* st)
+        const C_STRUCT aiString *st) {
-{
     if (!st) {
         return;
     }
@@ -566,8 +540,7 @@ ASSIMP_API void aiSetImportPropertyString(aiPropertyStore* p, const char* szName
 // ------------------------------------------------------------------------------------------------
 // Importer::SetPropertyMatrix
 ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore *p, const char *szName,
-    const C_STRUCT aiMatrix4x4* mat)
+        const C_STRUCT aiMatrix4x4 *mat) {
-{
     if (!mat) {
         return;
     }
@@ -579,8 +552,7 @@ ASSIMP_API void aiSetImportPropertyMatrix(aiPropertyStore* p, const char* szName
 
 // ------------------------------------------------------------------------------------------------
 // Rotation matrix to quaternion
-ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion* quat,const aiMatrix3x3* mat)
+ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion *quat, const aiMatrix3x3 *mat) {
-{
     ai_assert(NULL != quat);
     ai_assert(NULL != mat);
     *quat = aiQuaternion(*mat);
@@ -590,8 +562,7 @@ ASSIMP_API void aiCreateQuaternionFromMatrix(aiQuaternion* quat,const aiMatrix3x
 // Matrix decomposition
 ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4 *mat, aiVector3D *scaling,
         aiQuaternion *rotation,
-    aiVector3D* position)
+        aiVector3D *position) {
-{
     ai_assert(NULL != rotation);
     ai_assert(NULL != position);
     ai_assert(NULL != scaling);
@@ -601,15 +572,13 @@ ASSIMP_API void aiDecomposeMatrix(const aiMatrix4x4* mat,aiVector3D* scaling,
 
 // ------------------------------------------------------------------------------------------------
 // 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();
 }
@@ -617,8 +586,7 @@ ASSIMP_API void aiTransposeMatrix4(aiMatrix4x4* mat)
 // ------------------------------------------------------------------------------------------------
 // Vector transformation
 ASSIMP_API void aiTransformVecByMatrix3(aiVector3D *vec,
-    const aiMatrix3x3* mat)
+        const aiMatrix3x3 *mat) {
-{
     ai_assert(NULL != mat);
     ai_assert(NULL != vec);
     *vec *= (*mat);
@@ -626,8 +594,7 @@ ASSIMP_API void aiTransformVecByMatrix3(aiVector3D* vec,
 
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API void aiTransformVecByMatrix4(aiVector3D *vec,
-    const aiMatrix4x4* mat)
+        const aiMatrix4x4 *mat) {
-{
     ai_assert(NULL != mat);
     ai_assert(NULL != vec);
 
@@ -638,8 +605,7 @@ ASSIMP_API void aiTransformVecByMatrix4(aiVector3D* vec,
 // Matrix multiplication
 ASSIMP_API void aiMultiplyMatrix4(
         aiMatrix4x4 *dst,
-    const aiMatrix4x4* src)
+        const aiMatrix4x4 *src) {
-{
     ai_assert(NULL != dst);
     ai_assert(NULL != src);
     *dst = (*dst) * (*src);
@@ -648,8 +614,7 @@ ASSIMP_API void aiMultiplyMatrix4(
 // ------------------------------------------------------------------------------------------------
 ASSIMP_API void aiMultiplyMatrix3(
         aiMatrix3x3 *dst,
-    const aiMatrix3x3* src)
+        const aiMatrix3x3 *src) {
-{
     ai_assert(NULL != dst);
     ai_assert(NULL != src);
     *dst = (*dst) * (*src);
@@ -658,16 +623,14 @@ ASSIMP_API void aiMultiplyMatrix3(
 // ------------------------------------------------------------------------------------------------
 // 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();
 }
@@ -693,3 +656,598 @@ ASSIMP_API C_STRUCT const aiImporterDesc* aiGetImporterDesc( const char *extensi
 }
 
 // ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector2AreEqual(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector2AreEqualEpsilon(
+        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);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Add(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *src) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != src);
+    *dst = *dst + *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Subtract(
+        C_STRUCT aiVector2D *dst,
+        const C_STRUCT aiVector2D *src) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != src);
+    *dst = *dst - *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Scale(
+        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) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != other);
+    *dst = dst->SymMul(*other);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2DivideByScalar(
+        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) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != v);
+    *dst = *dst / *v;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector2Length(
+        const C_STRUCT aiVector2D *v) {
+    ai_assert(NULL != v);
+    return v->Length();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector2SquareLength(
+        const C_STRUCT aiVector2D *v) {
+    ai_assert(NULL != v);
+    return v->SquareLength();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Negate(
+        C_STRUCT aiVector2D *dst) {
+    ai_assert(NULL != dst);
+    *dst = -(*dst);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector2DotProduct(
+        const C_STRUCT aiVector2D *a,
+        const C_STRUCT aiVector2D *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return (*a) * (*b);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector2Normalize(
+        C_STRUCT aiVector2D *v) {
+    ai_assert(NULL != v);
+    v->Normalize();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector3AreEqual(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector3AreEqualEpsilon(
+        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);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiVector3LessThan(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return *a < *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Add(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *src) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != src);
+    *dst = *dst + *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Subtract(
+        C_STRUCT aiVector3D *dst,
+        const C_STRUCT aiVector3D *src) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != src);
+    *dst = *dst - *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Scale(
+        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) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != other);
+    *dst = dst->SymMul(*other);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3DivideByScalar(
+        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) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != v);
+    *dst = *dst / *v;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector3Length(
+        const C_STRUCT aiVector3D *v) {
+    ai_assert(NULL != v);
+    return v->Length();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector3SquareLength(
+        const C_STRUCT aiVector3D *v) {
+    ai_assert(NULL != v);
+    return v->SquareLength();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Negate(
+        C_STRUCT aiVector3D *dst) {
+    ai_assert(NULL != dst);
+    *dst = -(*dst);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API float aiVector3DotProduct(
+        const C_STRUCT aiVector3D *a,
+        const C_STRUCT aiVector3D *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return (*a) * (*b);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3CrossProduct(
+        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);
+    *dst = *a ^ *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3Normalize(
+        C_STRUCT aiVector3D *v) {
+    ai_assert(NULL != v);
+    v->Normalize();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3NormalizeSafe(
+        C_STRUCT aiVector3D *v) {
+    ai_assert(NULL != v);
+    v->NormalizeSafe();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiVector3RotateByQuaternion(
+        C_STRUCT aiVector3D *v,
+        const C_STRUCT aiQuaternion *q) {
+    ai_assert(NULL != v);
+    ai_assert(NULL != q);
+    *v = q->Rotate(*v);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromMatrix4(
+        C_STRUCT aiMatrix3x3 *dst,
+        const C_STRUCT aiMatrix4x4 *mat) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != mat);
+    *dst = aiMatrix3x3(*mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromQuaternion(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiQuaternion *q) {
+    ai_assert(NULL != mat);
+    ai_assert(NULL != q);
+    *mat = q->GetMatrix();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix3AreEqual(
+        const C_STRUCT aiMatrix3x3 *a,
+        const C_STRUCT aiMatrix3x3 *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix3AreEqualEpsilon(
+        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) {
+    ai_assert(NULL != mat);
+    mat->Inverse();
+}
+
+// ------------------------------------------------------------------------------------------------
+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) {
+    ai_assert(NULL != mat);
+    aiMatrix3x3::RotationZ(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromRotationAroundAxis(
+        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);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3Translation(
+        C_STRUCT aiMatrix3x3 *mat,
+        const C_STRUCT aiVector2D *translation) {
+    ai_assert(NULL != mat);
+    ai_assert(NULL != translation);
+    aiMatrix3x3::Translation(*translation, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix3FromTo(
+        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);
+    aiMatrix3x3::FromToMatrix(*from, *to, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromMatrix3(
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix3x3 *mat) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != mat);
+    *dst = aiMatrix4x4(*mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromScalingQuaternionPosition(
+        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);
+    ai_assert(NULL != position);
+    *mat = aiMatrix4x4(*scaling, *rotation, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Add(
+        C_STRUCT aiMatrix4x4 *dst,
+        const C_STRUCT aiMatrix4x4 *src) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != src);
+    *dst = *dst + *src;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix4AreEqual(
+        const C_STRUCT aiMatrix4x4 *a,
+        const C_STRUCT aiMatrix4x4 *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiMatrix4AreEqualEpsilon(
+        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) {
+    ai_assert(NULL != mat);
+    mat->Inverse();
+}
+
+// ------------------------------------------------------------------------------------------------
+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) {
+    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) {
+    ai_assert(NULL != mat);
+    ai_assert(NULL != scaling);
+    ai_assert(NULL != rotation);
+    ai_assert(NULL != position);
+    mat->Decompose(*scaling, *rotation, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition(
+        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);
+    ai_assert(NULL != angle);
+    ai_assert(NULL != position);
+    mat->Decompose(*scaling, *axis, *angle, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4DecomposeNoScaling(
+        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);
+    mat->DecomposeNoScaling(*rotation, *position);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromEulerAngles(
+        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) {
+    ai_assert(NULL != mat);
+    aiMatrix4x4::RotationX(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4RotationY(
+        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) {
+    ai_assert(NULL != mat);
+    aiMatrix4x4::RotationZ(angle, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromRotationAroundAxis(
+        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);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Translation(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *translation) {
+    ai_assert(NULL != mat);
+    ai_assert(NULL != translation);
+    aiMatrix4x4::Translation(*translation, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4Scaling(
+        C_STRUCT aiMatrix4x4 *mat,
+        const C_STRUCT aiVector3D *scaling) {
+    ai_assert(NULL != mat);
+    ai_assert(NULL != scaling);
+    aiMatrix4x4::Scaling(*scaling, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiMatrix4FromTo(
+        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);
+    aiMatrix4x4::FromToMatrix(*from, *to, *mat);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionFromEulerAngles(
+        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) {
+    ai_assert(NULL != q);
+    ai_assert(NULL != axis);
+    *q = aiQuaternion(*axis, angle);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionFromNormalizedQuaternion(
+        C_STRUCT aiQuaternion *q,
+        const C_STRUCT aiVector3D *normalized) {
+    ai_assert(NULL != q);
+    ai_assert(NULL != normalized);
+    *q = aiQuaternion(*normalized);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiQuaternionAreEqual(
+        const C_STRUCT aiQuaternion *a,
+        const C_STRUCT aiQuaternion *b) {
+    ai_assert(NULL != a);
+    ai_assert(NULL != b);
+    return *a == *b;
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API int aiQuaternionAreEqualEpsilon(
+        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);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionNormalize(
+        C_STRUCT aiQuaternion *q) {
+    ai_assert(NULL != q);
+    q->Normalize();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionConjugate(
+        C_STRUCT aiQuaternion *q) {
+    ai_assert(NULL != q);
+    q->Conjugate();
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionMultiply(
+        C_STRUCT aiQuaternion *dst,
+        const C_STRUCT aiQuaternion *q) {
+    ai_assert(NULL != dst);
+    ai_assert(NULL != q);
+    *dst = (*dst) * (*q);
+}
+
+// ------------------------------------------------------------------------------------------------
+ASSIMP_API void aiQuaternionInterpolate(
+        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);
+    aiQuaternion::Interpolate(*dst, *start, *end, factor);
+}

code/FBX/FBXConverter.cpp

@@ -655,7 +655,8 @@ bool FBXConverter::NeedsComplexTransformationChain(const Model &model) {
     for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
         const TransformationComp comp = static_cast<TransformationComp>(i);
 
-        if (comp == TransformationComp_Rotation || comp == TransformationComp_Scaling || comp == TransformationComp_Translation) {
+        if (comp == TransformationComp_Rotation || comp == TransformationComp_Scaling || comp == TransformationComp_Translation ||
+            comp == TransformationComp_PreRotation || comp == TransformationComp_PostRotation) {
             continue;
         }
 
@@ -856,9 +857,10 @@ bool FBXConverter::GenerateTransformationNodeChain(const Model &model, const std
 
     // name passed to the method is already unique
     nd->mName.Set(name);
-
+    // for (const auto &transform : chain) {
-    for (const auto &transform : chain) {
+    // skip inverse chain for no preservePivots
-        nd->mTransformation = nd->mTransformation * transform;
+    for (unsigned int i = TransformationComp_Translation; i < TransformationComp_MAXIMUM; i++) {
+      nd->mTransformation = nd->mTransformation * chain[i];
     }
     return false;
 }
@@ -2739,14 +2741,11 @@ void FBXConverter::GenerateNodeAnimations(std::vector<aiNodeAnim *> &node_anims,
     // scaling and translation _and_ there are no animated other components either,
     // we can use a single node and also a single node animation channel.
     if( !has_complex && !NeedsComplexTransformationChain(target)) {
-
         aiNodeAnim* const nd = GenerateSimpleNodeAnim(fixed_name, target, chain,
                 node_property_map.end(),
-                layer_map,
                 start, stop,
                 max_time,
-                min_time,
+                min_time
-                true // input is TRS order, assimp is SRT
         );
 
         ai_assert(nd);
@@ -3023,130 +3022,118 @@ aiNodeAnim *FBXConverter::GenerateTranslationNodeAnim(const std::string &name,
 aiNodeAnim* FBXConverter::GenerateSimpleNodeAnim(const std::string& name,
         const Model& target,
         NodeMap::const_iterator chain[TransformationComp_MAXIMUM],
-        NodeMap::const_iterator iter_end,
+        NodeMap::const_iterator iterEnd,
-        const LayerMap &layer_map,
         int64_t start, int64_t stop,
-        double &max_time,
+        double& maxTime,
-        double &min_time,
+        double& minTime)
-        bool reverse_order)
-
 {
     std::unique_ptr<aiNodeAnim> na(new aiNodeAnim());
     na->mNodeName.Set(name);
 
     const PropertyTable &props = target.Props();
 
-    // need to convert from TRS order to SRT?
+    // collect unique times and keyframe lists
-    if (reverse_order) {
+    KeyFrameListList keyframeLists[TransformationComp_MAXIMUM];
+    KeyTimeList keytimes;
 
-        aiVector3D def_scale = PropertyGet(props, "Lcl Scaling", aiVector3D(1.f, 1.f, 1.f));
+    for (size_t i = 0; i < TransformationComp_MAXIMUM; ++i) {
-        aiVector3D def_translate = PropertyGet(props, "Lcl Translation", aiVector3D(0.f, 0.f, 0.f));
+        if (chain[i] == iterEnd)
-        aiVector3D def_rot = PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f));
+            continue;
 
-        KeyFrameListList scaling;
+        keyframeLists[i] = GetKeyframeList((*chain[i]).second, start, stop);
-        KeyFrameListList translation;
-        KeyFrameListList rotation;
 
-        if (chain[TransformationComp_Scaling] != iter_end) {
+        for (KeyFrameListList::const_iterator it = keyframeLists[i].begin(); it != keyframeLists[i].end(); ++it) {
-            scaling = GetKeyframeList((*chain[TransformationComp_Scaling]).second, start, stop);
+            const KeyTimeList& times = *std::get<0>(*it);
+            keytimes.insert(keytimes.end(), times.begin(), times.end());
         }
 
-        if (chain[TransformationComp_Translation] != iter_end) {
+        // remove duplicates
-            translation = GetKeyframeList((*chain[TransformationComp_Translation]).second, start, stop);
+        std::sort(keytimes.begin(), keytimes.end());
+
+        auto last = std::unique(keytimes.begin(), keytimes.end());
+        keytimes.erase(last, keytimes.end());
     }
 
-        if (chain[TransformationComp_Rotation] != iter_end) {
+    const Model::RotOrder rotOrder = target.RotationOrder();
-            rotation = GetKeyframeList((*chain[TransformationComp_Rotation]).second, start, stop);
+    const size_t keyCount = keytimes.size();
+
+    aiVector3D defTranslate = PropertyGet(props, "Lcl Translation", aiVector3D(0.f, 0.f, 0.f));
+    aiVector3D defRotation = PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f));
+    aiVector3D defScale = PropertyGet(props, "Lcl Scaling", aiVector3D(1.f, 1.f, 1.f));
+    aiQuaternion defQuat = EulerToQuaternion(defRotation, rotOrder);
+
+    aiVectorKey* outTranslations = new aiVectorKey[keyCount];
+    aiQuatKey* outRotations = new aiQuatKey[keyCount];
+    aiVectorKey* outScales = new aiVectorKey[keyCount];
+
+    if (keyframeLists[TransformationComp_Translation].size() > 0) {
+        InterpolateKeys(outTranslations, keytimes, keyframeLists[TransformationComp_Translation], defTranslate, maxTime, minTime);
+    } else {
+        for (size_t i = 0; i < keyCount; ++i) {
+            outTranslations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outTranslations[i].mValue = defTranslate;
+        }
     }
 
-        KeyFrameListList joined;
+    if (keyframeLists[TransformationComp_Rotation].size() > 0) {
-        joined.insert(joined.end(), scaling.begin(), scaling.end());
+        InterpolateKeys(outRotations, keytimes, keyframeLists[TransformationComp_Rotation], defRotation, maxTime, minTime, rotOrder);
-        joined.insert(joined.end(), translation.begin(), translation.end());
+    } else {
-        joined.insert(joined.end(), rotation.begin(), rotation.end());
+        for (size_t i = 0; i < keyCount; ++i) {
-
+            outRotations[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
-        const KeyTimeList &times = GetKeyTimeList(joined);
+            outRotations[i].mValue = defQuat;
-
+        }
-        aiQuatKey *out_quat = new aiQuatKey[times.size()];
-        aiVectorKey *out_scale = new aiVectorKey[times.size()];
-        aiVectorKey *out_translation = new aiVectorKey[times.size()];
-
-        if (times.size()) {
-            ConvertTransformOrder_TRStoSRT(out_quat, out_scale, out_translation,
-                    scaling,
-                    translation,
-                    rotation,
-                    times,
-                    max_time,
-                    min_time,
-                    target.RotationOrder(),
-                    def_scale,
-                    def_translate,
-                    def_rot);
     }
 
-        // XXX remove duplicates / redundant keys which this operation did
+    if (keyframeLists[TransformationComp_Scaling].size() > 0) {
-        // likely produce if not all three channels were equally dense.
+        InterpolateKeys(outScales, keytimes, keyframeLists[TransformationComp_Scaling], defScale, maxTime, minTime);
+    } else {
+        for (size_t i = 0; i < keyCount; ++i) {
+            outScales[i].mTime = CONVERT_FBX_TIME(keytimes[i]) * anim_fps;
+            outScales[i].mValue = defScale;
+        }
+    }
 
-        na->mNumScalingKeys = static_cast<unsigned int>(times.size());
+    bool ok = false;
+    const float zero_epsilon = 1e-6f;
+
+    const aiVector3D& preRotation = PropertyGet<aiVector3D>(props, "PreRotation", ok);
+    if (ok && preRotation.SquareLength() > zero_epsilon) {
+        const aiQuaternion preQuat = EulerToQuaternion(preRotation, Model::RotOrder_EulerXYZ);
+        for (size_t i = 0; i < keyCount; ++i) {
+            outRotations[i].mValue = preQuat * outRotations[i].mValue;
+        }
+    }
+
+    const aiVector3D& postRotation = PropertyGet<aiVector3D>(props, "PostRotation", ok);
+    if (ok && postRotation.SquareLength() > zero_epsilon) {
+        const aiQuaternion postQuat = EulerToQuaternion(postRotation, Model::RotOrder_EulerXYZ);
+        for (size_t i = 0; i < keyCount; ++i) {
+            outRotations[i].mValue = outRotations[i].mValue * postQuat;
+        }
+    }
+
+    // convert TRS to SRT
+    for (size_t i = 0; i < keyCount; ++i) {
+        aiQuaternion& r = outRotations[i].mValue;
+        aiVector3D& s = outScales[i].mValue;
+        aiVector3D& t = outTranslations[i].mValue;
+
+        aiMatrix4x4 mat, temp;
+        aiMatrix4x4::Translation(t, mat);
+        mat *= aiMatrix4x4(r.GetMatrix());
+        mat *= aiMatrix4x4::Scaling(s, temp);
+
+        mat.Decompose(s, r, t);
+    }
+
+    na->mNumScalingKeys = static_cast<unsigned int>(keyCount);
     na->mNumRotationKeys = na->mNumScalingKeys;
     na->mNumPositionKeys = na->mNumScalingKeys;
 
-        na->mScalingKeys = out_scale;
+    na->mScalingKeys = outScales;
-        na->mRotationKeys = out_quat;
+    na->mRotationKeys = outRotations;
-        na->mPositionKeys = out_translation;
+    na->mPositionKeys = outTranslations;
-    } else {
 
-        // if a particular transformation is not given, grab it from
-        // the corresponding node to meet the semantics of aiNodeAnim,
-        // which requires all of rotation, scaling and translation
-        // to be set.
-        if (chain[TransformationComp_Scaling] != iter_end) {
-            ConvertScaleKeys(na.get(), (*chain[TransformationComp_Scaling]).second,
-                    layer_map,
-                    start, stop,
-                    max_time,
-                    min_time);
-        } else {
-            na->mScalingKeys = new aiVectorKey[1];
-            na->mNumScalingKeys = 1;
-
-            na->mScalingKeys[0].mTime = 0.;
-            na->mScalingKeys[0].mValue = PropertyGet(props, "Lcl Scaling",
-                    aiVector3D(1.f, 1.f, 1.f));
-        }
-
-        if (chain[TransformationComp_Rotation] != iter_end) {
-            ConvertRotationKeys(na.get(), (*chain[TransformationComp_Rotation]).second,
-                    layer_map,
-                    start, stop,
-                    max_time,
-                    min_time,
-                    target.RotationOrder());
-        } else {
-            na->mRotationKeys = new aiQuatKey[1];
-            na->mNumRotationKeys = 1;
-
-            na->mRotationKeys[0].mTime = 0.;
-            na->mRotationKeys[0].mValue = EulerToQuaternion(
-                    PropertyGet(props, "Lcl Rotation", aiVector3D(0.f, 0.f, 0.f)),
-                    target.RotationOrder());
-        }
-
-        if (chain[TransformationComp_Translation] != iter_end) {
-            ConvertTranslationKeys(na.get(), (*chain[TransformationComp_Translation]).second,
-                    layer_map,
-                    start, stop,
-                    max_time,
-                    min_time);
-        } else {
-            na->mPositionKeys = new aiVectorKey[1];
-            na->mNumPositionKeys = 1;
-
-            na->mPositionKeys[0].mTime = 0.;
-            na->mPositionKeys[0].mValue = PropertyGet(props, "Lcl Translation",
-                    aiVector3D(0.f, 0.f, 0.f));
-        }
-    }
     return na.release();
 }
 
@@ -3327,10 +3314,7 @@ void FBXConverter::InterpolateKeys(aiQuatKey *valOut, const KeyTimeList &keys, c
         // take shortest path by checking the inner product
         // http://www.3dkingdoms.com/weekly/weekly.php?a=36
         if (quat.x * lastq.x + quat.y * lastq.y + quat.z * lastq.z + quat.w * lastq.w < 0) {
-            quat.x = -quat.x;
+            quat.Conjugate();
-            quat.y = -quat.y;
-            quat.z = -quat.z;
-            quat.w = -quat.w;
         }
         lastq = quat;
 
@@ -3338,60 +3322,6 @@ void FBXConverter::InterpolateKeys(aiQuatKey *valOut, const KeyTimeList &keys, c
     }
 }
 
-void FBXConverter::ConvertTransformOrder_TRStoSRT(aiQuatKey *out_quat, aiVectorKey *out_scale,
-        aiVectorKey *out_translation,
-        const KeyFrameListList &scaling,
-        const KeyFrameListList &translation,
-        const KeyFrameListList &rotation,
-        const KeyTimeList &times,
-        double &maxTime,
-        double &minTime,
-        Model::RotOrder order,
-        const aiVector3D &def_scale,
-        const aiVector3D &def_translate,
-        const aiVector3D &def_rotation) {
-    if (rotation.size()) {
-        InterpolateKeys(out_quat, times, rotation, def_rotation, maxTime, minTime, order);
-    } else {
-        for (size_t i = 0; i < times.size(); ++i) {
-            out_quat[i].mTime = CONVERT_FBX_TIME(times[i]) * anim_fps;
-            out_quat[i].mValue = EulerToQuaternion(def_rotation, order);
-        }
-    }
-
-    if (scaling.size()) {
-        InterpolateKeys(out_scale, times, scaling, def_scale, maxTime, minTime);
-    } else {
-        for (size_t i = 0; i < times.size(); ++i) {
-            out_scale[i].mTime = CONVERT_FBX_TIME(times[i]) * anim_fps;
-            out_scale[i].mValue = def_scale;
-        }
-    }
-
-    if (translation.size()) {
-        InterpolateKeys(out_translation, times, translation, def_translate, maxTime, minTime);
-    } else {
-        for (size_t i = 0; i < times.size(); ++i) {
-            out_translation[i].mTime = CONVERT_FBX_TIME(times[i]) * anim_fps;
-            out_translation[i].mValue = def_translate;
-        }
-    }
-
-    const size_t count = times.size();
-    for (size_t i = 0; i < count; ++i) {
-        aiQuaternion &r = out_quat[i].mValue;
-        aiVector3D &s = out_scale[i].mValue;
-        aiVector3D &t = out_translation[i].mValue;
-
-        aiMatrix4x4 mat, temp;
-        aiMatrix4x4::Translation(t, mat);
-        mat *= aiMatrix4x4(r.GetMatrix());
-        mat *= aiMatrix4x4::Scaling(s, temp);
-
-        mat.Decompose(s, r, t);
-    }
-}
-
 aiQuaternion FBXConverter::EulerToQuaternion(const aiVector3D &rot, Model::RotOrder order) {
     aiMatrix4x4 m;
     GetRotationMatrix(order, rot, m);

code/FBX/FBXConverter.h

@@ -349,12 +349,10 @@ private:
     aiNodeAnim* GenerateSimpleNodeAnim(const std::string& name,
         const Model& target,
         NodeMap::const_iterator chain[TransformationComp_MAXIMUM],
-        NodeMap::const_iterator iter_end,
+        NodeMap::const_iterator iterEnd,
-        const LayerMap& layer_map,
         int64_t start, int64_t stop,
-        double& max_time,
+        double& maxTime,
-        double& min_time,
+        double& minTime);
-        bool reverse_order = false);
 
     // key (time), value, mapto (component index)
     typedef std::tuple<std::shared_ptr<KeyTimeList>, std::shared_ptr<KeyValueList>, unsigned int > KeyFrameList;
@@ -379,20 +377,6 @@ private:
         double& minTime,
         Model::RotOrder order);
 
-    // ------------------------------------------------------------------------------------------------
-    void ConvertTransformOrder_TRStoSRT(aiQuatKey* out_quat, aiVectorKey* out_scale,
-        aiVectorKey* out_translation,
-        const KeyFrameListList& scaling,
-        const KeyFrameListList& translation,
-        const KeyFrameListList& rotation,
-        const KeyTimeList& times,
-        double& maxTime,
-        double& minTime,
-        Model::RotOrder order,
-        const aiVector3D& def_scale,
-        const aiVector3D& def_translate,
-        const aiVector3D& def_rotation);
-
     // ------------------------------------------------------------------------------------------------
     // euler xyz -> quat
     aiQuaternion EulerToQuaternion(const aiVector3D& rot, Model::RotOrder order);

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
+struct ImportSettings {
-{
+    ImportSettings() :
-    ImportSettings()
+            strictMode(true),
-    : strictMode(true)
+            readAllLayers(true),
-    , readAllLayers(true)
+            readAllMaterials(false),
-    , readAllMaterials(false)
+            readMaterials(true),
-    , readMaterials(true)
+            readTextures(true),
-    , readTextures(true)
+            readCameras(true),
-    , readCameras(true)
+            readLights(true),
-    , readLights(true)
+            readAnimations(true),
-    , readAnimations(true)
+            readWeights(true),
-    , readWeights(true)
+            preservePivots(true),
-    , preservePivots(true)
+            optimizeEmptyAnimationCurves(true),
-    , optimizeEmptyAnimationCurves(true)
+            useLegacyEmbeddedTextureNaming(false),
-    , useLegacyEmbeddedTextureNaming(false)
+            removeEmptyBones(true),
-    , removeEmptyBones( true )
+            convertToMeters(false) {
-    , 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;
 };
 
-
+} // namespace FBX
-} // !FBX
+} // namespace Assimp
-} // !Assimp
 
 #endif
-

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,

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,
@@ -55,18 +54,20 @@ namespace Assimp    {
 
 // TinyFormatter.h
 namespace Formatter {
-    template <typename T,typename TR, typename A> class basic_formatter;
+
+template <typename T, typename TR, typename A>
+class basic_formatter;
+
 typedef class basic_formatter<char, std::char_traits<char>, std::allocator<char>> format;
-}
+
+} // namespace Formatter
 
 // -------------------------------------------------------------------------------------------
-/** Load the Autodesk FBX file format.
+/// Loads the Autodesk FBX file format.
-
+///
- See http://en.wikipedia.org/wiki/FBX
+/// See http://en.wikipedia.org/wiki/FBX
-*/
 // -------------------------------------------------------------------------------------------
-class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter>
+class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter> {
-{
 public:
     FBXImporter();
     virtual ~FBXImporter();
@@ -74,11 +75,9 @@ public:
     // --------------------
     bool CanRead(const std::string &pFile,
             IOSystem *pIOHandler,
-        bool checkSig
+            bool checkSig) const;
-    ) const;
 
 protected:
-
     // --------------------
     const aiImporterDesc *GetInfo() const;
 
@@ -88,8 +87,7 @@ protected:
     // --------------------
     void InternReadFile(const std::string &pFile,
             aiScene *pScene,
-        IOSystem* pIOHandler
+            IOSystem *pIOHandler);
-    );
 
 private:
     FBX::ImportSettings settings;
@@ -97,4 +95,3 @@ private:
 
 } // end of namespace Assimp
 #endif // !INCLUDED_AI_FBX_IMPORTER_H
-

code/Irr/IRRLoader.cpp

@@ -1483,6 +1483,7 @@ void IRRImporter::InternReadFile( const std::string& pFile,
      */
 
     delete root;
+	delete reader;
 }
 
 #endif // !! ASSIMP_BUILD_NO_IRR_IMPORTER

code/M3D/M3DExporter.cpp

@@ -312,7 +312,9 @@ void ExportSceneM3DA(
 M3DExporter::M3DExporter(const aiScene *pScene, const ExportProperties *pProperties) :
         mScene(pScene),
         mProperties(pProperties),
-        outfile() {}
+        outfile() {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 void M3DExporter::doExport(
@@ -352,6 +354,9 @@ void M3DExporter::doExport(
     // explicitly release file pointer,
     // so we don't have to rely on class destruction.
     outfile.reset();
+
+    M3D_FREE(m3d->name);
+    m3d->name = nullptr;
 }
 
 // ------------------------------------------------------------------------------------------------

code/M3D/M3DWrapper.cpp

@@ -121,8 +121,9 @@ M3DWrapper::~M3DWrapper() {
 
 void M3DWrapper::reset() {
     ClearSave();
-	if (m3d_)
+    if (m3d_) {
         m3d_free(m3d_);
+    }
     m3d_ = nullptr;
 }
 

code/M3D/m3d.h

@@ -5440,13 +5440,13 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         out += 2;
                         break;
                     case 4:
-                        *((float *)out) = vrtx[i].data.x;
+                        memcpy(out, &vrtx[i].data.x, sizeof(float));
                         out += 4;
-                        *((float *)out) = vrtx[i].data.y;
+                        memcpy(out, &vrtx[i].data.y, sizeof(float));
                         out += 4;
-                        *((float *)out) = vrtx[i].data.z;
+                        memcpy(out, &vrtx[i].data.z, sizeof(float));
                         out += 4;
-                        *((float *)out) = vrtx[i].data.w;
+                        memcpy(out, &vrtx[i].data.w, sizeof(float));
                         out += 4;
                         break;
                     case 8:
@@ -5474,9 +5474,11 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                 }
                 out = _m3d_addidx(out, sk_s, vrtx[i].data.skinid);
             }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            memcpy(length, &v, sizeof(uint32_t));
+            //*length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
             out = NULL;
-            len += *length;
+            len += v;
         }
         /* bones chunk */
         if (model->numbone && model->bone && !(flags & M3D_EXP_NOBONE)) {
@@ -5660,8 +5662,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         out = _m3d_addidx(out, vi_s, vrtxidx[face[i].data.normal[j]]);
                 }
             }
-            *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+            uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-            len += *length;
+            memcpy(length, &v, sizeof(uint32_t));
+            len += v;
             out = NULL;
         }
         /* mathematical shapes face */
@@ -5721,8 +5724,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         }
                     }
                 }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-                len += *length;
+                memcpy( length, &v, sizeof(uint32_t));
+                len += v;
                 out = NULL;
             }
         }
@@ -5765,8 +5769,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                 out = _m3d_addidx(out, si_s, _m3d_stridx(str, numstr, model->label[l].text));
             }
             if (length) {
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-                len += *length;
+                memcpy( length, &v, sizeof(uint32_t));                
+                len += v;
             }
             out = NULL;
             sn = sl = NULL;
@@ -5796,8 +5801,9 @@ unsigned char *m3d_save(m3d_t *model, int quality, int flags, unsigned int *size
                         out = _m3d_addidx(out, vi_s, vrtxidx[a->frame[i].transform[k].ori]);
                     }
                 }
-                *length = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
+                uint32_t v = (uint32_t)((uintptr_t)out - (uintptr_t)((uint8_t *)h + len));
-                len += *length;
+                memcpy( length, &v, sizeof(uint32_t));                
+                len += v;
                 out = NULL;
             }
         }

code/Material/MaterialSystem.cpp

@@ -503,7 +503,7 @@ aiReturn aiMaterial::AddBinaryProperty (const void* pInput,
     pcNew->mData = new char[pSizeInBytes];
     memcpy (pcNew->mData,pInput,pSizeInBytes);
 
-    pcNew->mKey.length = (ai_uint32)::strlen(pKey);
+    pcNew->mKey.length = static_cast<ai_uint32>( ::strlen(pKey) );
     ai_assert ( MAXLEN > pcNew->mKey.length);
     strcpy( pcNew->mKey.data, pKey );
 

code/Q3BSP/Q3BSPFileImporter.cpp

@@ -617,7 +617,7 @@ bool Q3BSPFileImporter::importTextureFromArchive( const Q3BSP::Q3BSPModel *model
             // We'll leave it up to the user to figure out which extension the file has.
             aiString name;
             strncpy( name.data, pTexture->strName, sizeof name.data );
-            name.length = (ai_uint32)strlen( name.data );
+            name.length = static_cast<ai_uint32>(strlen( name.data ));
             pMatHelper->AddProperty( &name, AI_MATKEY_TEXTURE_DIFFUSE( 0 ) );
         }
     }

code/SMD/SMDLoader.cpp

@@ -616,7 +616,7 @@ void SMDImporter::CreateOutputMaterials() {
         if (aszTextures[iMat].length())
         {
             ::strncpy(szName.data, aszTextures[iMat].c_str(),MAXLEN-1);
-            szName.length = (ai_uint32)aszTextures[iMat].length();
+            szName.length = static_cast<ai_uint32>( aszTextures[iMat].length() );
             pcMat->AddProperty(&szName,AI_MATKEY_TEXTURE_DIFFUSE(0));
         }
     }

code/Terragen/TerragenLoader.cpp

@@ -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,
@@ -43,17 +41,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file Implementation of the Terragen importer class */
 
-
-
 #ifndef ASSIMP_BUILD_NO_TERRAGEN_IMPORTER
 
 #include "TerragenLoader.h"
 #include <assimp/StreamReader.h>
-#include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
-#include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-#include <assimp/importerdesc.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/Importer.hpp>
 
 using namespace Assimp;
 
@@ -72,19 +68,16 @@ static const aiImporterDesc desc = {
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-TerragenImporter::TerragenImporter()
+TerragenImporter::TerragenImporter() :
-: configComputeUVs (false)
+        configComputeUVs(false) {}
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-TerragenImporter::~TerragenImporter()
+TerragenImporter::~TerragenImporter() {}
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool TerragenImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
+bool TerragenImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const {
-{
     // check file extension
     std::string extension = GetExtension(pFile);
 
@@ -105,15 +98,13 @@ bool TerragenImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler,
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* TerragenImporter::GetInfo () const
+const aiImporterDesc *TerragenImporter::GetInfo() const {
-{
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup import properties
-void TerragenImporter::SetupProperties(const Importer* pImp)
+void TerragenImporter::SetupProperties(const Importer *pImp) {
-{
     // AI_CONFIG_IMPORT_TER_MAKE_UVS
     configComputeUVs = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_TER_MAKE_UVS, 0));
 }
@@ -121,8 +112,7 @@ void TerragenImporter::SetupProperties(const Importer* pImp)
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void TerragenImporter::InternReadFile(const std::string &pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
+        aiScene *pScene, IOSystem *pIOHandler) {
-{
     IOStream *file = pIOHandler->Open(pFile, "rb");
 
     // Check whether we can read from the file
@@ -151,8 +141,7 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
 
     // Now read all chunks until we're finished or an EOF marker is encountered
     reader.IncPtr(16);
-    while (reader.GetRemainingSize() >= 4)
+    while (reader.GetRemainingSize() >= 4) {
-    {
         const char *head = (const char *)reader.GetPtr();
         reader.IncPtr(4);
 
@@ -161,42 +150,35 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
             break;
 
         // Number of x-data points
-        if (!::strncmp(head,AI_TERR_CHUNK_XPTS,4))
+        if (!::strncmp(head, AI_TERR_CHUNK_XPTS, 4)) {
-        {
             x = (uint16_t)reader.GetI2();
         }
         // Number of y-data points
-        else if (!::strncmp(head,AI_TERR_CHUNK_YPTS,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_YPTS, 4)) {
-        {
             y = (uint16_t)reader.GetI2();
         }
         // Squared terrains width-1.
-        else if (!::strncmp(head,AI_TERR_CHUNK_SIZE,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_SIZE, 4)) {
-        {
             x = y = (uint16_t)reader.GetI2() + 1;
         }
         // terrain scaling
-        else if (!::strncmp(head,AI_TERR_CHUNK_SCAL,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_SCAL, 4)) {
-        {
             root->mTransformation.a1 = reader.GetF4();
             root->mTransformation.b2 = reader.GetF4();
             root->mTransformation.c3 = reader.GetF4();
         }
         // mapping == 1: earth radius
-        else if (!::strncmp(head,AI_TERR_CHUNK_CRAD,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_CRAD, 4)) {
-        {
             reader.GetF4();
         }
         // mapping mode
-        else if (!::strncmp(head,AI_TERR_CHUNK_CRVM,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_CRVM, 4)) {
-        {
             mode = reader.GetI1();
             if (0 != mode)
                 ASSIMP_LOG_ERROR("TER: Unsupported mapping mode, a flat terrain is returned");
         }
         // actual terrain data
-        else if (!::strncmp(head,AI_TERR_CHUNK_ALTW,4))
+        else if (!::strncmp(head, AI_TERR_CHUNK_ALTW, 4)) {
-        {
             float hscale = (float)reader.GetI2() / 65536;
             float bheight = (float)reader.GetI2();
 
@@ -247,8 +229,10 @@ void TerragenImporter::InternReadFile( const std::string& pFile,
 
                     // make indices
                     f->mIndices = new unsigned int[f->mNumIndices = 4];
-                    for (unsigned int i = 0; i < 4;++i)
+                    for (unsigned int i = 0; i < 4; ++i) {
-                        f->mIndices[i] = t++;
+                        f->mIndices[i] = t;
+                        t++;
+                    }
                 }
             }
 

code/Terragen/TerragenLoader.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,
@@ -69,21 +68,17 @@ namespace Assimp    {
  *  The loader is basing on the information found here:
  *  http://www.planetside.co.uk/terragen/dev/tgterrain.html#chunks
 */
-class TerragenImporter : public BaseImporter
+class TerragenImporter : public BaseImporter {
-{
 public:
     TerragenImporter();
     ~TerragenImporter();
 
-
 public:
-
     // -------------------------------------------------------------------
     bool CanRead(const std::string &pFile, IOSystem *pIOHandler,
             bool checkSig) const;
 
 protected:
-
     // -------------------------------------------------------------------
     const aiImporterDesc *GetInfo() const;
 
@@ -95,7 +90,6 @@ protected:
     void SetupProperties(const Importer *pImp);
 
 private:
-
     bool configComputeUVs;
 
 }; //! class TerragenImporter

code/Unreal/UnrealLoader.cpp

@@ -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,
@@ -48,26 +46,112 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *    http://local.wasp.uwa.edu.au/~pbourke/dataformats/unreal/
  */
 
-
-
 #ifndef ASSIMP_BUILD_NO_3D_IMPORTER
 
 #include "Unreal/UnrealLoader.h"
 #include "PostProcessing/ConvertToLHProcess.h"
 
-#include <assimp/StreamReader.h>
 #include <assimp/ParsingUtils.h>
+#include <assimp/StreamReader.h>
 #include <assimp/fast_atof.h>
-#include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
+#include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/IOSystem.hpp>
-#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
-#include <assimp/importerdesc.h>
 
+#include <stdint.h>
 #include <memory>
 
 using namespace Assimp;
 
+namespace Unreal {
+
+/*
+    0 = Normal one-sided
+    1 = Normal two-sided
+    2 = Translucent two-sided
+    3 = Masked two-sided
+    4 = Modulation blended two-sided
+    8 = Placeholder triangle for weapon positioning (invisible)
+    */
+enum MeshFlags {
+    MF_NORMAL_OS = 0,
+    MF_NORMAL_TS = 1,
+    MF_NORMAL_TRANS_TS = 2,
+    MF_NORMAL_MASKED_TS = 3,
+    MF_NORMAL_MOD_TS = 4,
+    MF_WEAPON_PLACEHOLDER = 8
+};
+
+// a single triangle
+struct Triangle {
+    uint16_t mVertex[3]; // Vertex indices
+    char mType; // James' Mesh Type
+    char mColor; // Color for flat and Gourand Shaded
+    unsigned char mTex[3][2]; // Texture UV coordinates
+    unsigned char mTextureNum; // Source texture offset
+    char mFlags; // Unreal Mesh Flags (unused)
+    unsigned int matIndex;
+};
+
+// temporary representation for a material
+struct TempMat {
+    TempMat() :
+            type(MF_NORMAL_OS), tex(), numFaces(0) {}
+
+    explicit TempMat(const Triangle &in) :
+            type((Unreal::MeshFlags)in.mType), tex(in.mTextureNum), numFaces(0) {}
+
+    // type of mesh
+    Unreal::MeshFlags type;
+
+    // index of texture
+    unsigned int tex;
+
+    // number of faces using us
+    unsigned int numFaces;
+
+    // for std::find
+    bool operator==(const TempMat &o) {
+        return (tex == o.tex && type == o.type);
+    }
+};
+
+struct Vertex {
+    int32_t X : 11;
+    int32_t Y : 11;
+    int32_t Z : 10;
+};
+
+// UNREAL vertex compression
+inline void CompressVertex(const aiVector3D &v, uint32_t &out) {
+    union {
+        Vertex n;
+        int32_t t;
+    };
+    t = 0;
+    n.X = (int32_t)v.x;
+    n.Y = (int32_t)v.y;
+    n.Z = (int32_t)v.z;
+    ::memcpy(&out, &t, sizeof(int32_t));
+}
+
+// UNREAL vertex decompression
+inline void DecompressVertex(aiVector3D &v, int32_t in) {
+    union {
+        Vertex n;
+        int32_t i;
+    };
+    i = in;
+
+    v.x = (float)n.X;
+    v.y = (float)n.Y;
+    v.z = (float)n.Z;
+}
+
+} // end namespace Unreal
+
 static const aiImporterDesc desc = {
     "Unreal Mesh Importer",
     "",
@@ -81,54 +165,46 @@ static const aiImporterDesc desc = {
     "3d uc"
 };
 
-
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
-UnrealImporter::UnrealImporter()
+UnrealImporter::UnrealImporter() :
-:   configFrameID   (0)
+        mConfigFrameID(0), mConfigHandleFlags(true) {}
-,   configHandleFlags (true)
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-UnrealImporter::~UnrealImporter()
+UnrealImporter::~UnrealImporter() {}
-{}
 
 // ------------------------------------------------------------------------------------------------
 // Returns whether the class can handle the format of the given file.
-bool UnrealImporter::CanRead( const std::string& pFile, IOSystem* /*pIOHandler*/, bool /*checkSig*/) const
+bool UnrealImporter::CanRead(const std::string &pFile, IOSystem * /*pIOHandler*/, bool /*checkSig*/) const {
-{
     return SimpleExtensionCheck(pFile, "3d", "uc");
 }
 
 // ------------------------------------------------------------------------------------------------
 // Build a string of all file extensions supported
-const aiImporterDesc* UnrealImporter::GetInfo () const
+const aiImporterDesc *UnrealImporter::GetInfo() const {
-{
     return &desc;
 }
 
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
-void UnrealImporter::SetupProperties(const Importer* pImp)
+void UnrealImporter::SetupProperties(const Importer *pImp) {
-{
     // The
     // AI_CONFIG_IMPORT_UNREAL_KEYFRAME option overrides the
     // AI_CONFIG_IMPORT_GLOBAL_KEYFRAME option.
-    configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME,-1);
+    mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_KEYFRAME, -1);
-    if(static_cast<unsigned int>(-1) == configFrameID)  {
+    if (static_cast<unsigned int>(-1) == mConfigFrameID) {
-        configFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME,0);
+        mConfigFrameID = pImp->GetPropertyInteger(AI_CONFIG_IMPORT_GLOBAL_KEYFRAME, 0);
     }
 
     // AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, default is true
-    configHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS,1));
+    mConfigHandleFlags = (0 != pImp->GetPropertyInteger(AI_CONFIG_IMPORT_UNREAL_HANDLE_FLAGS, 1));
 }
 
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void UnrealImporter::InternReadFile(const std::string &pFile,
-    aiScene* pScene, IOSystem* pIOHandler)
+        aiScene *pScene, IOSystem *pIOHandler) {
-{
     // For any of the 3 files being passed get the three correct paths
     // First of all, determine file extension
     std::string::size_type pos = pFile.find_last_of('.');
@@ -143,8 +219,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
             throw DeadlyImportError("UNREAL: Unexpected naming scheme");
         }
         extension = pFile.substr(0, pos);
-    }
+    } else {
-    else {
         extension = pFile.substr(0, pos);
     }
 
@@ -186,7 +261,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         tri.mType = d_reader.GetI1();
 
         // handle mesh flagss?
-        if (configHandleFlags)
+        if (mConfigHandleFlags)
             tri.mType = Unreal::MF_NORMAL_OS;
         else {
             // ignore MOD and MASKED for the moment, treat them as two-sided
@@ -211,7 +286,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
     // read number of frames
     const uint32_t numFrames = a_reader.GetI2();
-    if (configFrameID >= numFrames) {
+    if (mConfigFrameID >= numFrames) {
         throw DeadlyImportError("UNREAL: The requested frame does not exist");
     }
 
@@ -220,7 +295,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
         throw DeadlyImportError("UNREAL: Unexpected aniv file length");
 
     // skip to our frame
-    a_reader.IncPtr(configFrameID *numVert*4);
+    a_reader.IncPtr(mConfigFrameID * numVert * 4);
 
     // collect vertices
     std::vector<aiVector3D> vertices(numVert);
@@ -261,12 +336,13 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                         for (; !IsLineEnd(*data); ++data) {
                             if (!::ASSIMP_strincmp(data, "NAME=", 5)) {
                                 const char *d = data += 5;
-                                for (;!IsSpaceOrNewLine(*data);++data);
+                                for (; !IsSpaceOrNewLine(*data); ++data)
+                                    ;
                                 me.first = std::string(d, (size_t)(data - d));
-                            }
+                            } else if (!::ASSIMP_strincmp(data, "FILE=", 5)) {
-                            else if (!::ASSIMP_strincmp(data,"FILE=",5))    {
                                 const char *d = data += 5;
-                                for (;!IsSpaceOrNewLine(*data);++data);
+                                for (; !IsSpaceOrNewLine(*data); ++data)
+                                    ;
                                 me.second = std::string(d, (size_t)(data - d));
                             }
                         }
@@ -288,11 +364,11 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                             if (!::ASSIMP_strincmp(data, "NUM=", 4)) {
                                 data += 4;
                                 me.first = strtoul10(data, &data);
-                            }
+                            } else if (!::ASSIMP_strincmp(data, "TEXTURE=", 8)) {
-                            else if (!::ASSIMP_strincmp(data,"TEXTURE=",8)) {
                                 data += 8;
                                 const char *d = data;
-                                for (;!IsSpaceOrNewLine(*data);++data);
+                                for (; !IsSpaceOrNewLine(*data); ++data)
+                                    ;
                                 me.second = std::string(d, (size_t)(data - d));
 
                                 // try to find matching path names, doesn't care if we don't find them
@@ -305,17 +381,14 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                                 }
                             }
                         }
-                    }
+                    } else if (TokenMatchI(data, "SCALE", 5)) {
-                    else if (TokenMatchI(data,"SCALE",5)) {
 
                         for (; !IsLineEnd(*data); ++data) {
                             if (data[0] == 'X' && data[1] == '=') {
                                 data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.a1);
-                            }
+                            } else if (data[0] == 'Y' && data[1] == '=') {
-                            else if (data[0] == 'Y' && data[1] == '=')  {
                                 data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.b2);
-                            }
+                            } else if (data[0] == 'Z' && data[1] == '=') {
-                            else if (data[0] == 'Z' && data[1] == '=')  {
                                 data = fast_atoreal_move<float>(data + 2, (float &)nd->mTransformation.c3);
                             }
                         }
@@ -323,8 +396,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
                 }
             }
         }
-    }
+    } else {
-    else    {
         ASSIMP_LOG_ERROR("Unable to open .uc file");
     }
 
@@ -342,8 +414,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
             materials.push_back(mat);
 
             ++pScene->mNumMeshes;
-        }
+        } else {
-        else {
             tri.matIndex = static_cast<unsigned int>(nt - materials.begin());
             ++nt->numFaces;
         }
@@ -385,16 +456,16 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
             const int twosided = 1;
             mat->AddProperty(&twosided, 1, AI_MATKEY_TWOSIDED);
             ::strcat(s.data, "ts_");
-        }
+        } else
-        else ::strcat(s.data,"os_");
+            ::strcat(s.data, "os_");
 
         // make TRANS faces 90% opaque that RemRedundantMaterials won't catch us
         if (materials[i].type == Unreal::MF_NORMAL_TRANS_TS) {
             const float opac = 0.9f;
             mat->AddProperty(&opac, 1, AI_MATKEY_OPACITY);
             ::strcat(s.data, "tran_");
-        }
+        } else
-        else ::strcat(s.data,"opaq_");
+            ::strcat(s.data, "opaq_");
 
         // a special name for the weapon attachment point
         if (materials[i].type == Unreal::MF_WEAPON_PLACEHOLDER) {
@@ -404,7 +475,7 @@ void UnrealImporter::InternReadFile( const std::string& pFile,
 
         // set color and name
         mat->AddProperty(&color, 1, AI_MATKEY_COLOR_DIFFUSE);
-        s.length = (ai_uint32)::strlen(s.data);
+        s.length = static_cast<ai_uint32>(::strlen(s.data));
         mat->AddProperty(&s, AI_MATKEY_NAME);
 
         // set texture, if any

code/Unreal/UnrealLoader.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,
@@ -47,118 +46,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_3D_LOADER_H
 
 #include <assimp/BaseImporter.h>
-#include <stdint.h>
 
 namespace Assimp {
-namespace Unreal {
-
-    /*
-    0 = Normal one-sided
-    1 = Normal two-sided
-    2 = Translucent two-sided
-    3 = Masked two-sided
-    4 = Modulation blended two-sided
-    8 = Placeholder triangle for weapon positioning (invisible)
-    */
-enum MeshFlags {
-    MF_NORMAL_OS            = 0,
-    MF_NORMAL_TS            = 1,
-    MF_NORMAL_TRANS_TS      = 2,
-    MF_NORMAL_MASKED_TS     = 3,
-    MF_NORMAL_MOD_TS        = 4,
-    MF_WEAPON_PLACEHOLDER   = 8
-};
-
-    // a single triangle
-struct Triangle {
-   uint16_t mVertex[3];       // Vertex indices
-   char mType;                // James' Mesh Type
-   char mColor;               // Color for flat and Gourand Shaded
-   unsigned char mTex[3][2];  // Texture UV coordinates
-   unsigned char mTextureNum; // Source texture offset
-   char mFlags;               // Unreal Mesh Flags (unused)
-
-   unsigned int matIndex;
-};
-
-// temporary representation for a material
-struct TempMat  {
-    TempMat()
-        :   type()
-        ,   tex()
-        ,   numFaces    (0)
-    {}
-
-    explicit TempMat(const Triangle& in)
-        :   type        ((Unreal::MeshFlags)in.mType)
-        ,   tex         (in.mTextureNum)
-        ,   numFaces    (0)
-    {}
-
-    // type of mesh
-    Unreal::MeshFlags type;
-
-    // index of texture
-    unsigned int tex;
-
-    // number of faces using us
-    unsigned int numFaces;
-
-    // for std::find
-    bool operator == (const TempMat& o )    {
-        return (tex == o.tex && type == o.type);
-    }
-};
-
-struct Vertex
-{
-    int32_t X : 11;
-    int32_t Y : 11;
-    int32_t Z : 10;
-};
-
-    // UNREAL vertex compression
-inline void CompressVertex(const aiVector3D& v, uint32_t& out)
-{
-    union {
-        Vertex n;
-        int32_t t;
-    };
-    n.X = (int32_t)v.x;
-    n.Y = (int32_t)v.y;
-    n.Z = (int32_t)v.z;
-    ::memcpy( &out, &t, sizeof(int32_t));
-    //out = t;
-}
-
-    // UNREAL vertex decompression
-inline void DecompressVertex(aiVector3D& v, int32_t in)
-{
-    union {
-        Vertex n;
-        int32_t i;
-    };
-    i = in;
-
-    v.x = (float)n.X;
-    v.y = (float)n.Y;
-    v.z = (float)n.Z;
-}
-
-} // end namespace Unreal
 
 // ---------------------------------------------------------------------------
 /** @brief Importer class to load UNREAL files (*.3d)
 */
-class UnrealImporter : public BaseImporter
+class UnrealImporter : public BaseImporter {
-{
 public:
     UnrealImporter();
     ~UnrealImporter();
 
-
-public:
-
     // -------------------------------------------------------------------
     /** @brief Returns whether we can handle the format of the given file
      *
@@ -168,7 +66,6 @@ public:
             bool checkSig) const;
 
 protected:
-
     // -------------------------------------------------------------------
     /** @brief Called by Importer::GetExtensionList()
      *
@@ -176,7 +73,6 @@ protected:
      */
     const aiImporterDesc *GetInfo() const;
 
-
     // -------------------------------------------------------------------
     /** @brief Setup properties for the importer
      *
@@ -184,7 +80,6 @@ protected:
      */
     void SetupProperties(const Importer *pImp);
 
-
     // -------------------------------------------------------------------
     /** @brief Imports the given file into the given scene structure.
      *
@@ -194,14 +89,14 @@ protected:
             IOSystem *pIOHandler);
 
 private:
-
     //! frame to be loaded
-    uint32_t configFrameID;
+    uint32_t mConfigFrameID;
 
     //! process surface flags
-    bool configHandleFlags;
+    bool mConfigHandleFlags;
 
 }; // !class UnrealImporter
 
 } // end of namespace Assimp
+
 #endif // AI_UNREALIMPORTER_H_INC

code/XGL/XGLLoader.cpp

@@ -176,7 +176,7 @@ void XGLImporter::InternReadFile( const std::string& pFile,
         raw_reader->IncPtr(2);
 
         zstream.next_in   = reinterpret_cast<Bytef*>( raw_reader->GetPtr() );
-        zstream.avail_in  = raw_reader->GetRemainingSize();
+        zstream.avail_in  = (uInt) raw_reader->GetRemainingSize();
 
         size_t total = 0l;
 

code/glTF2/glTF2Asset.inl

@@ -508,18 +508,23 @@ inline size_t Buffer::AppendData(uint8_t *data, size_t length) {
 }
 
 inline void Buffer::Grow(size_t amount) {
-    if (amount <= 0) return;
+    if (amount <= 0) {
+        return;
+    }
+    
+    // Capacity is big enough
     if (capacity >= byteLength + amount) {
         byteLength += amount;
         return;
     }
 
-    // Shift operation is standard way to divide integer by 2, it doesn't cast it to float back and forth, also works for odd numbers,
+    // Just allocate data which we need
-    // originally it would look like: static_cast<size_t>(capacity * 1.5f)
+    capacity = byteLength + amount;
-    capacity = std::max(capacity + (capacity >> 1), byteLength + amount);
 
     uint8_t *b = new uint8_t[capacity];
-    if (mData) memcpy(b, mData.get(), byteLength);
+    if (nullptr != mData) {
+        memcpy(b, mData.get(), byteLength);
+    }
     mData.reset(b, std::default_delete<uint8_t[]>());
     byteLength += amount;
 }

code/glTF2/glTF2Importer.cpp

@@ -952,7 +952,7 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
 
 void glTF2Importer::ImportNodes(glTF2::Asset &r) {
 	if (!r.scene) {
-        return;
+		throw DeadlyImportError("GLTF: No scene");
 	}
 
 	std::vector<Ref<Node>> rootNodes = r.scene->nodes;
@@ -970,6 +970,8 @@ void glTF2Importer::ImportNodes(glTF2::Asset &r) {
 			root->mChildren[root->mNumChildren++] = node;
 		}
 		mScene->mRootNode = root;
+	} else {
+		mScene->mRootNode = new aiNode("ROOT");
 	}
 }
 

contrib/CMakeLists.txt

@@ -1,4 +1,4 @@
 # Compile internal irrXML only if system is not requested
-if( NOT SYSTEM_IRRXML )
+if( NOT ASSIMP_SYSTEM_IRRXML )
     add_subdirectory(irrXML)
 endif()

contrib/irrXML/CMakeLists.txt

@@ -15,7 +15,11 @@ if ( MSVC )
 endif ( MSVC )
 
 IF(CMAKE_SYSTEM_NAME MATCHES "(Darwin|FreeBSD)")
+  IF(APPLE)
+    add_library(IrrXML STATIC ${IrrXML_SRCS})
+  ELSE()
     add_library(IrrXML ${IrrXML_SRCS})
+  ENDIF()
 ELSE()
   add_library(IrrXML STATIC ${IrrXML_SRCS})
 ENDIF()

contrib/irrXML/CXMLReaderImpl.h

@@ -8,16 +8,7 @@
 #include "irrXML.h"
 #include "irrString.h"
 #include "irrArray.h"
-
+#include "fast_atof.h"
-#include <cassert>
-#include <stdlib.h>    
-#include <cctype>
-#include <cstdint>
-//using namespace Assimp;
-
-// For locale independent number conversion
-#include <sstream>
-#include <locale>
 
 #ifdef _DEBUG
 #define IRR_DEBUGPRINT(x) printf((x));
@@ -37,14 +28,23 @@ template<class char_type, class superclass>
 class CXMLReaderImpl : public IIrrXMLReader<char_type, superclass>
 {
 public:
-
 	//! Constructor
 	CXMLReaderImpl(IFileReadCallBack* callback, bool deleteCallBack = true) 
-		: TextData(0), P(0), TextBegin(0), TextSize(0), CurrentNodeType(EXN_NONE),
+	: TextData(0)
-		SourceFormat(ETF_ASCII), TargetFormat(ETF_ASCII)
+	, P(0)
-	{
+	, TextBegin(0)
-		if (!callback)
+	, TextSize(0)
+	, CurrentNodeType(EXN_NONE)
+	, SourceFormat(ETF_ASCII)
+	, TargetFormat(ETF_ASCII)
+	, NodeName ()
+	, EmptyString()
+	, IsEmptyElement(false)
+	, SpecialCharacters()
+	, Attributes() {
+		if (!callback) {
 			return;
+		}
 
 		storeTargetFormat();
 
@@ -168,8 +168,7 @@ public:
 			return 0;
 
 		core::stringc c = attr->Value.c_str();
-        return static_cast<float>(atof(c.c_str()));
+		return core::fast_atof(c.c_str());
-        //return fast_atof(c.c_str());
 	}
 
 
@@ -181,11 +180,7 @@ public:
 			return 0;
 
 		core::stringc c = attrvalue;
-		std::istringstream sstr(c.c_str());
+		return core::fast_atof(c.c_str());
-		sstr.imbue(std::locale("C")); // Locale free number convert
-		float fNum;
-		sstr >> fNum;
-		return fNum;
 	}
 
 
@@ -228,7 +223,7 @@ private:
 	{
 		char_type* start = P;
 
-		// move forward until '<' found
+		// more forward until '<' found
 		while(*P != L'<' && *P)
 			++P;
 
@@ -438,10 +433,6 @@ private:
 		while(*P != L'>')
 			++P;
 
-    // remove trailing whitespace, if any
-    while( std::isspace( P[-1]))
-      --P;
-
 		NodeName = core::string<char_type>(pBeginClose, (int)(P - pBeginClose));
 		++P;
 	}
@@ -676,12 +667,8 @@ private:
 
 			TextData = new char_type[sizeWithoutHeader];
 
-			// MSVC debugger complains here about loss of data ...
-			size_t numShift = sizeof( char_type) * 8;
-			assert(numShift < 64);
-			const src_char_type cc = (src_char_type)(((uint64_t(1u) << numShift) - 1));
 			for (int i=0; i<sizeWithoutHeader; ++i)
-				TextData[i] = char_type( source[i] & cc); 
+				TextData[i] = (char_type)source[i];
 
 			TextBegin = TextData;
 			TextSize = sizeWithoutHeader;

contrib/irrXML/fast_atof.h

@@ -0,0 +1,139 @@
+// Copyright (C) 2002-2005 Nikolaus Gebhardt
+// This file is part of the "Irrlicht Engine" and the "irrXML" project.
+// For conditions of distribution and use, see copyright notice in irrlicht.h and irrXML.h
+
+#ifndef __FAST_A_TO_F_H_INCLUDED__
+#define __FAST_A_TO_F_H_INCLUDED__
+
+#include <stdlib.h>
+#include <math.h>
+
+namespace irr
+{
+namespace core
+{
+
+const float fast_atof_table[] =	{
+										0.f,
+										0.1f,
+										0.01f,
+										0.001f,
+										0.0001f,
+										0.00001f,
+										0.000001f,
+										0.0000001f,
+										0.00000001f,
+										0.000000001f,
+										0.0000000001f,
+										0.00000000001f,
+										0.000000000001f,
+										0.0000000000001f,
+										0.00000000000001f,
+										0.000000000000001f
+									};
+
+//! Provides a fast function for converting a string into a float,
+//! about 6 times faster than atof in win32.
+// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
+inline char* fast_atof_move(char* c, float& out)
+{
+	bool inv = false;
+	char *t;
+	float f;
+
+	if (*c=='-')
+	{
+		c++;
+		inv = true;
+	}
+
+	f = (float)strtol(c, &t, 10);
+
+	c = t;
+
+	if (*c == '.')
+	{
+		c++;
+
+		float pl = (float)strtol(c, &t, 10);
+		pl *= fast_atof_table[t-c];
+
+		f += pl;
+
+		c = t;
+
+		if (*c == 'e')
+		{
+			++c;
+			float exp = (float)strtol(c, &t, 10);
+			f *= (float)pow(10.0f, exp);
+			c = t;
+		}
+	}
+
+	if (inv)
+		f *= -1.0f;
+	
+	out = f;
+	return c;
+}
+
+//! Provides a fast function for converting a string into a float,
+//! about 6 times faster than atof in win32.
+// If you find any bugs, please send them to me, niko (at) irrlicht3d.org.
+inline const char* fast_atof_move_const(const char* c, float& out)
+{
+	bool inv = false;
+	char *t;
+	float f;
+
+	if (*c=='-')
+	{
+		c++;
+		inv = true;
+	}
+
+	f = (float)strtol(c, &t, 10);
+
+	c = t;
+
+	if (*c == '.')
+	{
+		c++;
+
+		float pl = (float)strtol(c, &t, 10);
+		pl *= fast_atof_table[t-c];
+
+		f += pl;
+
+		c = t;
+
+		if (*c == 'e') 
+		{ 
+			++c; 
+			f32 exp = (f32)strtol(c, &t, 10); 
+			f *= (f32)powf(10.0f, exp); 
+			c = t; 
+		}
+	}
+
+	if (inv)
+		f *= -1.0f;
+	
+	out = f;
+	return c;
+}
+
+
+inline float fast_atof(const char* c)
+{
+	float ret;
+	fast_atof_move_const(c, ret);
+	return ret;
+}
+
+} // end namespace core
+}// end namespace irr
+
+#endif
+

contrib/irrXML/irrArray.h

@@ -21,6 +21,7 @@ class array
 {
 
 public:
+
 	array()
 		: data(0), allocated(0), used(0),
 			free_when_destroyed(true), is_sorted(true)

contrib/irrXML/irrTypes.h

@@ -79,13 +79,8 @@ typedef unsigned short wchar_t;
 #endif // microsoft compiler
 
 //! define a break macro for debugging only in Win32 mode.
-// WORKAROUND (assimp): remove __asm
+#if !defined(_WIN64) && defined(WIN32) && defined(_MSC_VER) && defined(_DEBUG)
-#if defined(WIN32) && defined(_MSC_VER) && defined(_DEBUG)
+#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) if (_CONDITION_) {_asm int 3}
-#if defined(_M_IX86)
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ ) /*if (_CONDITION_) {_asm int 3}*/
-#else
-#define _IRR_DEBUG_BREAK_IF( _CONDITION_ )
-#endif
 #else 
 #define _IRR_DEBUG_BREAK_IF( _CONDITION_ )
 #endif
@@ -96,10 +91,8 @@ When you call unmanaged code that returns a bool type value of false from manage
 the return value may appear as true. See 
 http://support.microsoft.com/default.aspx?kbid=823071 for details. 
 Compiler version defines: VC6.0 : 1200, VC7.0 : 1300, VC7.1 : 1310, VC8.0 : 1400*/
-
+#if !defined(_WIN64) && defined(WIN32) && defined(_MSC_VER) && (_MSC_VER > 1299) && (_MSC_VER < 1400)
-// WORKAROUND (assimp): remove __asm 
+#define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX __asm mov eax,100
-#if defined(WIN32) && defined(_MSC_VER) && (_MSC_VER > 1299) && (_MSC_VER < 1400)
-#define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX /*__asm mov eax,100*/
 #else
 #define _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX
 #endif // _IRR_MANAGED_MARSHALLING_BUGFIX

contrib/irrXML/irrXML.cpp

@@ -2,14 +2,10 @@
 // This file is part of the "Irrlicht Engine" and the "irrXML" project.
 // For conditions of distribution and use, see copyright notice in irrlicht.h and/or irrXML.h
 
-// Need to include Assimp, too. We're using Assimp's version of fast_atof
-// so we need stdint.h. But no PCH.
-
-
 #include "irrXML.h"
 #include "irrString.h"
 #include "irrArray.h"
-//#include <assimp/fast_atof.h>
+#include "fast_atof.h"
 #include "CXMLReaderImpl.h"
 
 namespace irr
@@ -18,7 +14,7 @@ namespace io
 {
 
 //! Implementation of the file read callback for ordinary files
-class IRRXML_API CFileReadCallBack : public IFileReadCallBack
+class CFileReadCallBack : public IFileReadCallBack
 {
 public:
 

contrib/irrXML/irrXML.h

@@ -7,12 +7,6 @@
 
 #include <stdio.h>
 
-#ifdef _WIN32
-#   define IRRXML_API __declspec(dllexport)
-#else
-#   define IRRXML_API __attribute__ ((visibility("default")))
-#endif // _WIN32
-
 /** \mainpage irrXML 1.2 API documentation
  <div align="center"><img src="logobig.png" ></div>
 
@@ -178,7 +172,7 @@ namespace io
 		ETF_UTF32_BE,
 
 		//! UTF-32 format, little endian
-		ETF_UTF32_LE
+		ETF_UTF32_LE,
 	};
 
 
@@ -215,7 +209,7 @@ namespace io
 	two methods to read your data and give a pointer to an instance of
 	your implementation when calling createIrrXMLReader(), 
 	createIrrXMLReaderUTF16() or createIrrXMLReaderUTF32() */
-	class IRRXML_API IFileReadCallBack
+	class IFileReadCallBack
 	{
 	public:
 
@@ -415,7 +409,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(const char* filename);
+	IrrXMLReader* createIrrXMLReader(const char* filename);
 
 	//! Creates an instance of an UFT-8 or ASCII character xml parser.
 	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can 
@@ -427,7 +421,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(FILE* file);
+	IrrXMLReader* createIrrXMLReader(FILE* file);
 
 	//! Creates an instance of an UFT-8 or ASCII character xml parser. 
 	/** This means that all character data will be returned in 8 bit ASCII or UTF-8. The file to read can 
@@ -440,7 +434,7 @@ namespace io
 	 \return Returns a pointer to the created xml parser. This pointer should be 
 	 deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	 and the file could not be opened. */
-    IRRXML_API IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback);
+	IrrXMLReader* createIrrXMLReader(IFileReadCallBack* callback);
 
 	//! Creates an instance of an UFT-16 xml parser. 
 	/** This means that
@@ -452,7 +446,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename);
+	IrrXMLReaderUTF16* createIrrXMLReaderUTF16(const char* filename);
 
 	//! Creates an instance of an UFT-16 xml parser. 
 	/** This means that all character data will be returned in UTF-16. The file to read can 
@@ -464,7 +458,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file);
+	IrrXMLReaderUTF16* createIrrXMLReaderUTF16(FILE* file);
 
 	//! Creates an instance of an UFT-16 xml parser. 
 	/** This means that all character data will be returned in UTF-16. The file to read can 
@@ -477,7 +471,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback);
+	IrrXMLReaderUTF16* createIrrXMLReaderUTF16(IFileReadCallBack* callback);
 
 
 	//! Creates an instance of an UFT-32 xml parser. 
@@ -489,7 +483,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename);
+	IrrXMLReaderUTF32* createIrrXMLReaderUTF32(const char* filename);
 
 	//! Creates an instance of an UFT-32 xml parser. 
 	/** This means that all character data will be returned in UTF-32. The file to read can 
@@ -501,7 +495,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file);
+	IrrXMLReaderUTF32* createIrrXMLReaderUTF32(FILE* file);
 
 	//! Creates an instance of an UFT-32 xml parser. 
 	/** This means that
@@ -515,7 +509,7 @@ namespace io
 	\return Returns a pointer to the created xml parser. This pointer should be 
 	deleted using 'delete' after no longer needed. Returns 0 if an error occured
 	and the file could not be opened. */
-    IRRXML_API IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback);
+	IrrXMLReaderUTF32* createIrrXMLReaderUTF32(IFileReadCallBack* callback);
 	
 
 	/*! \file irrxml.h

include/assimp/MathFunctions.h

@@ -55,36 +55,51 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace Math {
 
-// TODO: use binary GCD for unsigned integers ....
+/// @brief  Will return the greatest common divisor.
+/// @param  a   [in] Value a.
+/// @param  b   [in] Value b.
+/// @return The greatest common divisor.
 template <typename IntegerType>
-inline
+inline IntegerType gcd( IntegerType a, IntegerType b ) {
-IntegerType gcd( IntegerType a, IntegerType b ) {
 	const IntegerType zero = (IntegerType)0;
 	while ( true ) {
-		if ( a == zero )
+		if ( a == zero ) {
 			return b;
+        }
 		b %= a;
 
-		if ( b == zero )
+		if ( b == zero ) {
 			return a;
+        }
 		a %= b;
 	}
 }
 
+/// @brief  Will return the greatest common divisor.
+/// @param  a   [in] Value a.
+/// @param  b   [in] Value b.
+/// @return The greatest common divisor.
 template < typename IntegerType >
-inline
+inline IntegerType lcm( IntegerType a, IntegerType b ) {
-IntegerType lcm( IntegerType a, IntegerType b ) {
 	const IntegerType t = gcd (a,b);
-	if (!t)
+	if (!t) {
         return t;
+    }
 	return a / t * b;
 }
-
+/// @brief  Will return the smallest epsilon-value for the requested type. 
+/// @return The numercical limit epsilon depending on its type.
 template<class T>
-inline
+inline T getEpsilon() {
-T getEpsilon() {
     return std::numeric_limits<T>::epsilon();
 }
 
+/// @brief  Will return the constant PI for the requested type.
+/// @return Pi
+template<class T>
+inline T PI() {
+    return static_cast<T>(3.14159265358979323846);
 }
-}
+
+} // namespace Math
+} // namespace Assimp

include/assimp/StreamReader.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,
@@ -52,10 +50,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #pragma GCC system_header
 #endif
 
-#include <assimp/IOStream.hpp>
-#include <assimp/Defines.h>
 #include <assimp/ByteSwapper.h>
+#include <assimp/Defines.h>
 #include <assimp/Exceptional.h>
+#include <assimp/IOStream.hpp>
 
 #include <memory>
 
@@ -74,10 +72,8 @@ namespace Assimp {
 template <bool SwapEndianess = false, bool RuntimeSwitch = false>
 class StreamReader {
 public:
-    // FIXME: use these data types throughout the whole library,
+    using diff = size_t;
-    // then change them to 64 bit values :-)
+    using pos = size_t;
-    using diff = int;
-    using pos  = unsigned int;
 
     // ---------------------------------------------------------------------
     /** Construction from a given stream with a well-defined endianness.
@@ -91,39 +87,44 @@ public:
      *    stream is in little endian byte order. Otherwise the
      *    endianness information is contained in the @c SwapEndianess
      *    template parameter and this parameter is meaningless.  */
-    StreamReader(std::shared_ptr<IOStream> stream, bool le = false)
+    StreamReader(std::shared_ptr<IOStream> stream, bool le = false) :
-        : stream(stream)
+            mStream(stream),
-        , le(le)
+            mBuffer(nullptr),
-    {
+            mCurrent(nullptr),
+            mEnd(nullptr),
+            mLimit(nullptr),
+            mLe(le) {
         ai_assert(stream);
         InternBegin();
     }
 
     // ---------------------------------------------------------------------
-    StreamReader(IOStream* stream, bool le = false)
+    StreamReader(IOStream *stream, bool le = false) :
-        : stream(std::shared_ptr<IOStream>(stream))
+            mStream(std::shared_ptr<IOStream>(stream)),
-        , le(le)
+            mBuffer(nullptr),
-    {
+            mCurrent(nullptr),
-        ai_assert(stream);
+            mEnd(nullptr),
+            mLimit(nullptr),
+            mLe(le) {
+        ai_assert(nullptr != stream);
         InternBegin();
     }
 
     // ---------------------------------------------------------------------
     ~StreamReader() {
-        delete[] buffer;
+        delete[] mBuffer;
     }
 
     // deprecated, use overloaded operator>> instead
 
     // ---------------------------------------------------------------------
-    /** Read a float from the stream  */
+    /// Read a float from the stream.
-    float GetF4()
+    float GetF4() {
-    {
         return Get<float>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a double from the stream  */
+    /// Read a double from the stream.
     double GetF8() {
         return Get<double>();
     }
@@ -159,42 +160,42 @@ public:
     }
 
     // ---------------------------------------------------------------------
-    /** Read a unsigned 8 bit integer from the stream */
+    /// Read a unsigned 8 bit integer from the stream
     uint8_t GetU1() {
         return Get<uint8_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read an unsigned 32 bit integer from the stream */
+    /// Read an unsigned 32 bit integer from the stream
     uint32_t GetU4() {
         return Get<uint32_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Read a unsigned 64 bit integer from the stream */
+    /// Read a unsigned 64 bit integer from the stream
     uint64_t GetU8() {
         return Get<uint64_t>();
     }
 
     // ---------------------------------------------------------------------
-    /** Get the remaining stream size (to the end of the stream) */
+    /// Get the remaining stream size (to the end of the stream)
-    unsigned int GetRemainingSize() const {
+    size_t GetRemainingSize() const {
-        return (unsigned int)(end - current);
+        return (unsigned int)(mEnd - mCurrent);
     }
 
     // ---------------------------------------------------------------------
     /** Get the remaining stream size (to the current read limit). The
      *  return value is the remaining size of the stream if no custom
      *  read limit has been set. */
-    unsigned int GetRemainingSizeToLimit() const {
+    size_t GetRemainingSizeToLimit() const {
-        return (unsigned int)(limit - current);
+        return (unsigned int)(mLimit - mCurrent);
     }
 
     // ---------------------------------------------------------------------
     /** Increase the file pointer (relative seeking)  */
     void IncPtr(intptr_t plus) {
-        current += plus;
+        mCurrent += plus;
-        if (current > limit) {
+        if (mCurrent > mLimit) {
             throw DeadlyImportError("End of file or read limit was reached");
         }
     }
@@ -202,7 +203,7 @@ public:
     // ---------------------------------------------------------------------
     /** Get the current file pointer */
     int8_t *GetPtr() const {
-        return current;
+        return mCurrent;
     }
 
     // ---------------------------------------------------------------------
@@ -212,8 +213,8 @@ public:
      *  @param p The new pointer, which is validated against the size
      *    limit and buffer boundaries. */
     void SetPtr(int8_t *p) {
-        current = p;
+        mCurrent = p;
-        if (current > limit || current < buffer) {
+        if (mCurrent > mLimit || mCurrent < mBuffer) {
             throw DeadlyImportError("End of file or read limit was reached");
         }
     }
@@ -229,14 +230,13 @@ public:
         ::memcpy(out, ur, bytes);
     }
 
-    // ---------------------------------------------------------------------
+    /// @brief Get the current offset from the beginning of the file
-    /** Get the current offset from the beginning of the file */
     int GetCurrentPos() const {
-        return (unsigned int)(current - buffer);
+        return (unsigned int)(mCurrent - mBuffer);
     }
 
     void SetCurrentPos(size_t pos) {
-        SetPtr(buffer + pos);
+        SetPtr(mBuffer + pos);
     }
 
     // ---------------------------------------------------------------------
@@ -249,12 +249,12 @@ public:
     unsigned int SetReadLimit(unsigned int _limit) {
         unsigned int prev = GetReadLimit();
         if (UINT_MAX == _limit) {
-            limit = end;
+            mLimit = mEnd;
             return prev;
         }
 
-        limit = buffer + _limit;
+        mLimit = mBuffer + _limit;
-        if (limit > end) {
+        if (mLimit > mEnd) {
             throw DeadlyImportError("StreamReader: Invalid read limit");
         }
         return prev;
@@ -264,14 +264,14 @@ public:
     /** Get the current read limit in bytes. Reading over this limit
      *  accidentally raises an exception.  */
     unsigned int GetReadLimit() const {
-        return (unsigned int)(limit - buffer);
+        return (unsigned int)(mLimit - mBuffer);
     }
 
     // ---------------------------------------------------------------------
     /** Skip to the read limit in bytes. Reading over this limit
      *  accidentally raises an exception. */
     void SkipToReadLimit() {
-        current = limit;
+        mCurrent = mLimit;
     }
 
     // ---------------------------------------------------------------------
@@ -286,14 +286,14 @@ public:
     /** Generic read method. ByteSwap::Swap(T*) *must* be defined */
     template <typename T>
     T Get() {
-        if ( current + sizeof(T) > limit) {
+        if (mCurrent + sizeof(T) > mLimit) {
             throw DeadlyImportError("End of file or stream limit was reached");
         }
 
         T f;
-        ::memcpy (&f, current, sizeof(T));
+        ::memcpy(&f, mCurrent, sizeof(T));
-        Intern::Getter<SwapEndianess,T,RuntimeSwitch>() (&f,le);
+        Intern::Getter<SwapEndianess, T, RuntimeSwitch>()(&f, mLe);
-        current += sizeof(T);
+        mCurrent += sizeof(T);
 
         return f;
     }
@@ -301,31 +301,29 @@ public:
 private:
     // ---------------------------------------------------------------------
     void InternBegin() {
-        if (!stream) {
+        if (nullptr == mStream) {
-            // in case someone wonders: StreamReader is frequently invoked with
-            // no prior validation whether the input stream is valid. Since
-            // no one bothers changing the error message, this message here
-            // is passed down to the caller and 'unable to open file'
-            // simply describes best what happened.
             throw DeadlyImportError("StreamReader: Unable to open file");
         }
 
-        const size_t s = stream->FileSize() - stream->Tell();
+        const size_t filesize = mStream->FileSize() - mStream->Tell();
-        if (!s) {
+        if (0 == filesize) {
             throw DeadlyImportError("StreamReader: File is empty or EOF is already reached");
         }
 
-        current = buffer = new int8_t[s];
+        mCurrent = mBuffer = new int8_t[filesize];
-        const size_t read = stream->Read(current,1,s);
+        const size_t read = mStream->Read(mCurrent, 1, filesize);
         // (read < s) can only happen if the stream was opened in text mode, in which case FileSize() is not reliable
-        ai_assert(read <= s);
+        ai_assert(read <= filesize);
-        end = limit = &buffer[read-1] + 1;
+        mEnd = mLimit = &mBuffer[read - 1] + 1;
     }
 
 private:
-    std::shared_ptr<IOStream> stream;
+    std::shared_ptr<IOStream> mStream;
-    int8_t *buffer, *current, *end, *limit;
+    int8_t *mBuffer;
-    bool le;
+    int8_t *mCurrent;
+    int8_t *mEnd;
+    int8_t *mLimit;
+    bool mLe;
 };
 
 // --------------------------------------------------------------------------------------------

include/assimp/cimport.h

@@ -562,6 +562,675 @@ ASSIMP_API size_t aiGetImportFormatCount(void);
  * @return A description of that specific import format. NULL if pIndex is out of range.
  */
 ASSIMP_API const C_STRUCT aiImporterDesc* aiGetImportFormatDescription( size_t pIndex);
+
+// --------------------------------------------------------------------------------
+/** Check if 2D vectors are equal.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector2AreEqual(
+    const C_STRUCT aiVector2D* a,
+    const C_STRUCT aiVector2D* b);
+
+// --------------------------------------------------------------------------------
+/** Check if 2D vectors are equal using epsilon.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector2AreEqualEpsilon(
+    const C_STRUCT aiVector2D* a,
+    const C_STRUCT aiVector2D* b,
+    const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Add 2D vectors.
+ *  @param dst First addend, receives result.
+ *  @param src Vector to be added to 'dst'.
+ */
+ASSIMP_API void aiVector2Add(
+    C_STRUCT aiVector2D* dst,
+    const C_STRUCT aiVector2D* src);
+
+// --------------------------------------------------------------------------------
+/** Subtract 2D vectors.
+ *  @param dst Minuend, receives result.
+ *  @param src Vector to be subtracted from 'dst'.
+ */
+ASSIMP_API void aiVector2Subtract(
+    C_STRUCT aiVector2D* dst,
+    const C_STRUCT aiVector2D* src);
+
+// --------------------------------------------------------------------------------
+/** Multiply a 2D vector by a scalar.
+ *  @param dst Vector to be scaled by \p s
+ *  @param s Scale factor
+ */
+ASSIMP_API void aiVector2Scale(
+    C_STRUCT aiVector2D* dst,
+    const float s);
+
+// --------------------------------------------------------------------------------
+/** Multiply each component of a 2D vector with
+ *  the components of another vector.
+ *  @param dst First vector, receives result
+ *  @param other Second vector
+ */
+ASSIMP_API void aiVector2SymMul(
+    C_STRUCT aiVector2D* dst,
+    const C_STRUCT aiVector2D* other);
+
+// --------------------------------------------------------------------------------
+/** Divide a 2D vector by a scalar.
+ *  @param dst Vector to be divided by \p s
+ *  @param s Scalar divisor
+ */
+ASSIMP_API void aiVector2DivideByScalar(
+    C_STRUCT aiVector2D* dst,
+    const float s);
+
+// --------------------------------------------------------------------------------
+/** Divide each component of a 2D vector by
+ *  the components of another vector.
+ *  @param dst Vector as the dividend
+ *  @param v Vector as the divisor
+ */
+ASSIMP_API void aiVector2DivideByVector(
+    C_STRUCT aiVector2D* dst,
+    C_STRUCT aiVector2D* v);
+
+// --------------------------------------------------------------------------------
+/** Get the length of a 2D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector2Length(
+    const C_STRUCT aiVector2D* v);
+
+// --------------------------------------------------------------------------------
+/** Get the squared length of a 2D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector2SquareLength(
+    const C_STRUCT aiVector2D* v);
+
+// --------------------------------------------------------------------------------
+/** Negate a 2D vector.
+ *  @param dst Vector to be negated
+ */
+ASSIMP_API void aiVector2Negate(
+    C_STRUCT aiVector2D* dst);
+
+// --------------------------------------------------------------------------------
+/** Get the dot product of 2D vectors.
+ *  @param a First vector
+ *  @param b Second vector
+ *  @return The dot product of vectors
+ */
+ASSIMP_API float aiVector2DotProduct(
+    const C_STRUCT aiVector2D* a,
+    const C_STRUCT aiVector2D* b);
+
+// --------------------------------------------------------------------------------
+/** Normalize a 2D vector.
+ *  @param v Vector to normalize
+ */
+ASSIMP_API void aiVector2Normalize(
+    C_STRUCT aiVector2D* v);
+
+// --------------------------------------------------------------------------------
+/** Check if 3D vectors are equal.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector3AreEqual(
+    const C_STRUCT aiVector3D* a,
+    const C_STRUCT aiVector3D* b);
+
+// --------------------------------------------------------------------------------
+/** Check if 3D vectors are equal using epsilon.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the vectors are equal
+ *  @return 0 if the vectors are not equal
+ */
+ASSIMP_API int aiVector3AreEqualEpsilon(
+    const C_STRUCT aiVector3D* a,
+    const C_STRUCT aiVector3D* b,
+    const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Check if vector \p a is less than vector \p b.
+ *  @param a First vector to compare
+ *  @param b Second vector to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if \p a is less than \p b
+ *  @return 0 if \p a is equal or greater than \p b
+ */
+ASSIMP_API int aiVector3LessThan(
+    const C_STRUCT aiVector3D* a,
+    const C_STRUCT aiVector3D* b);
+
+// --------------------------------------------------------------------------------
+/** Add 3D vectors.
+ *  @param dst First addend, receives result.
+ *  @param src Vector to be added to 'dst'.
+ */
+ASSIMP_API void aiVector3Add(
+    C_STRUCT aiVector3D* dst,
+    const C_STRUCT aiVector3D* src);
+
+// --------------------------------------------------------------------------------
+/** Subtract 3D vectors.
+ *  @param dst Minuend, receives result.
+ *  @param src Vector to be subtracted from 'dst'.
+ */
+ASSIMP_API void aiVector3Subtract(
+    C_STRUCT aiVector3D* dst,
+    const C_STRUCT aiVector3D* src);
+
+// --------------------------------------------------------------------------------
+/** Multiply a 3D vector by a scalar.
+ *  @param dst Vector to be scaled by \p s
+ *  @param s Scale factor
+ */
+ASSIMP_API void aiVector3Scale(
+    C_STRUCT aiVector3D* dst,
+    const float s);
+
+// --------------------------------------------------------------------------------
+/** Multiply each component of a 3D vector with
+ *  the components of another vector.
+ *  @param dst First vector, receives result
+ *  @param other Second vector
+ */
+ASSIMP_API void aiVector3SymMul(
+    C_STRUCT aiVector3D* dst,
+    const C_STRUCT aiVector3D* other);
+
+// --------------------------------------------------------------------------------
+/** Divide a 3D vector by a scalar.
+ *  @param dst Vector to be divided by \p s
+ *  @param s Scalar divisor
+ */
+ASSIMP_API void aiVector3DivideByScalar(
+    C_STRUCT aiVector3D* dst,
+    const float s);
+
+// --------------------------------------------------------------------------------
+/** Divide each component of a 3D vector by
+ *  the components of another vector.
+ *  @param dst Vector as the dividend
+ *  @param v Vector as the divisor
+ */
+ASSIMP_API void aiVector3DivideByVector(
+    C_STRUCT aiVector3D* dst,
+    C_STRUCT aiVector3D* v);
+
+// --------------------------------------------------------------------------------
+/** Get the length of a 3D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector3Length(
+    const C_STRUCT aiVector3D* v);
+
+// --------------------------------------------------------------------------------
+/** Get the squared length of a 3D vector.
+ *  @return v Vector to evaluate
+ */
+ASSIMP_API float aiVector3SquareLength(
+    const C_STRUCT aiVector3D* v);
+
+// --------------------------------------------------------------------------------
+/** Negate a 3D vector.
+ *  @param dst Vector to be negated
+ */
+ASSIMP_API void aiVector3Negate(
+    C_STRUCT aiVector3D* dst);
+
+// --------------------------------------------------------------------------------
+/** Get the dot product of 3D vectors.
+ *  @param a First vector
+ *  @param b Second vector
+ *  @return The dot product of vectors
+ */
+ASSIMP_API float aiVector3DotProduct(
+    const C_STRUCT aiVector3D* a,
+    const C_STRUCT aiVector3D* b);
+
+// --------------------------------------------------------------------------------
+/** Get cross product of 3D vectors.
+ *  @param dst Vector to receive the result.
+ *  @param a First vector
+ *  @param b Second vector
+ *  @return The dot product of vectors
+ */
+ASSIMP_API void aiVector3CrossProduct(
+    C_STRUCT aiVector3D* dst,
+    const C_STRUCT aiVector3D* a,
+    const C_STRUCT aiVector3D* b);
+
+// --------------------------------------------------------------------------------
+/** Normalize a 3D vector.
+ *  @param v Vector to normalize
+ */
+ASSIMP_API void aiVector3Normalize(
+    C_STRUCT aiVector3D* v);
+
+// --------------------------------------------------------------------------------
+/** Check for division by zero and normalize a 3D vector.
+ *  @param v Vector to normalize
+ */
+ASSIMP_API void aiVector3NormalizeSafe(
+    C_STRUCT aiVector3D* v);
+
+// --------------------------------------------------------------------------------
+/** Rotate a 3D vector by a quaternion.
+ *  @param v The vector to rotate by \p q
+ *  @param q Quaternion to use to rotate \p v
+ */
+ASSIMP_API void aiVector3RotateByQuaternion(
+    C_STRUCT aiVector3D* v,
+    const C_STRUCT aiQuaternion* q);
+
+// --------------------------------------------------------------------------------
+/** Construct a 3x3 matrix from a 4x4 matrix.
+ *  @param dst Receives the output matrix
+ *  @param mat The 4x4 matrix to use
+ */
+ASSIMP_API void aiMatrix3FromMatrix4(
+    C_STRUCT aiMatrix3x3* dst,
+    const C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Construct a 3x3 matrix from a quaternion.
+ *  @param mat Receives the output matrix
+ *  @param q The quaternion matrix to use
+ */
+ASSIMP_API void aiMatrix3FromQuaternion(
+    C_STRUCT aiMatrix3x3* mat,
+    const C_STRUCT aiQuaternion* q);
+
+// --------------------------------------------------------------------------------
+/** Check if 3x3 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix3AreEqual(
+    const C_STRUCT aiMatrix3x3* a,
+    const C_STRUCT aiMatrix3x3* b);
+
+// --------------------------------------------------------------------------------
+/** Check if 3x3 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix3AreEqualEpsilon(
+    const C_STRUCT aiMatrix3x3* a,
+    const C_STRUCT aiMatrix3x3* b,
+    const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Invert a 3x3 matrix.
+ *  @param mat Matrix to invert
+ */
+ASSIMP_API void aiMatrix3Inverse(
+    C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Get the determinant of a 3x3 matrix.
+ *  @param mat Matrix to get the determinant from
+ */
+ASSIMP_API float aiMatrix3Determinant(
+    const C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Get a 3x3 rotation matrix around the Z axis.
+ *  @param mat Receives the output matrix 
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix3RotationZ(
+    C_STRUCT aiMatrix3x3* mat,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Returns a 3x3 rotation matrix for a rotation around an arbitrary axis.
+ *  @param mat Receives the output matrix 
+ *  @param axis Rotation axis, should be a normalized vector
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix3FromRotationAroundAxis(
+    C_STRUCT aiMatrix3x3* mat,
+    const C_STRUCT aiVector3D* axis,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 3x3 translation matrix.
+ *  @param mat Receives the output matrix 
+ *  @param translation The translation vector
+ */
+ASSIMP_API void aiMatrix3Translation(
+    C_STRUCT aiMatrix3x3* mat,
+    const C_STRUCT aiVector2D* translation);
+
+// --------------------------------------------------------------------------------
+/** Create a 3x3 matrix that rotates one vector to another vector.
+ *  @param mat Receives the output matrix 
+ *  @param from Vector to rotate from
+ *  @param to Vector to rotate to
+ */
+ASSIMP_API void aiMatrix3FromTo(
+    C_STRUCT aiMatrix3x3* mat,
+    const C_STRUCT aiVector3D* from,
+    const C_STRUCT aiVector3D* to);
+
+// --------------------------------------------------------------------------------
+/** Construct a 4x4 matrix from a 3x3 matrix.
+ *  @param dst Receives the output matrix
+ *  @param mat The 3x3 matrix to use
+ */
+ASSIMP_API void aiMatrix4FromMatrix3(
+    C_STRUCT aiMatrix4x4* dst,
+    const C_STRUCT aiMatrix3x3* mat);
+
+// --------------------------------------------------------------------------------
+/** Construct a 4x4 matrix from scaling, rotation and position.
+ *  @param mat Receives the output matrix.
+ *  @param scaling The scaling for the x,y,z axes
+ *  @param rotation The rotation as a hamilton quaternion
+ *  @param position The position for the x,y,z axes
+ */
+ASSIMP_API void aiMatrix4FromScalingQuaternionPosition(
+    C_STRUCT aiMatrix4x4* mat,
+    const C_STRUCT aiVector3D* scaling,
+    const C_STRUCT aiQuaternion* rotation,
+    const C_STRUCT aiVector3D* position);
+
+// --------------------------------------------------------------------------------
+/** Add 4x4 matrices.
+ *  @param dst First addend, receives result.
+ *  @param src Matrix to be added to 'dst'.
+ */
+ASSIMP_API void aiMatrix4Add(
+    C_STRUCT aiMatrix4x4* dst,
+    const C_STRUCT aiMatrix4x4* src);
+
+// --------------------------------------------------------------------------------
+/** Check if 4x4 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix4AreEqual(
+    const C_STRUCT aiMatrix4x4* a,
+    const C_STRUCT aiMatrix4x4* b);
+
+// --------------------------------------------------------------------------------
+/** Check if 4x4 matrices are equal.
+ *  @param a First matrix to compare
+ *  @param b Second matrix to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the matrices are equal
+ *  @return 0 if the matrices are not equal
+ */
+ASSIMP_API int aiMatrix4AreEqualEpsilon(
+    const C_STRUCT aiMatrix4x4* a,
+    const C_STRUCT aiMatrix4x4* b,
+    const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Invert a 4x4 matrix.
+ *  @param result Matrix to invert
+ */
+ASSIMP_API void aiMatrix4Inverse(
+    C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Get the determinant of a 4x4 matrix.
+ *  @param mat Matrix to get the determinant from
+ *  @return The determinant of the matrix
+ */
+ASSIMP_API float aiMatrix4Determinant(
+    const C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Returns true of the matrix is the identity matrix.
+ *  @param mat Matrix to get the determinant from
+ *  @return 1 if \p mat is an identity matrix.
+ *  @return 0 if \p mat is not an identity matrix.
+ */
+ASSIMP_API int aiMatrix4IsIdentity(
+    const C_STRUCT aiMatrix4x4* mat);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its scaling,
+ *  rotational as euler angles, and translational components.
+ *
+ * @param mat Matrix to decompose
+ * @param scaling Receives the output scaling for the x,y,z axes
+ * @param rotation Receives the output rotation as a Euler angles
+ * @param position Receives the output position for the x,y,z axes
+ */
+ASSIMP_API void aiMatrix4DecomposeIntoScalingEulerAnglesPosition(
+    const C_STRUCT aiMatrix4x4* mat,
+    C_STRUCT aiVector3D* scaling,
+    C_STRUCT aiVector3D* rotation,
+    C_STRUCT aiVector3D* position);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its scaling,
+ *  rotational split into an axis and rotational angle,
+ *  and it's translational components.
+ *
+ * @param mat Matrix to decompose
+ * @param rotation Receives the rotational component
+ * @param axis Receives the output rotation axis
+ * @param angle Receives the output rotation angle
+ * @param position Receives the output position for the x,y,z axes.
+ */
+ASSIMP_API void aiMatrix4DecomposeIntoScalingAxisAnglePosition(
+    const C_STRUCT aiMatrix4x4* mat,
+    C_STRUCT aiVector3D* scaling,
+    C_STRUCT aiVector3D* axis,
+    float* angle,
+    C_STRUCT aiVector3D* position);
+
+// --------------------------------------------------------------------------------
+/** Decompose a transformation matrix into its rotational and
+ *  translational components.
+ *
+ * @param mat Matrix to decompose
+ * @param rotation Receives the rotational component
+ * @param position Receives the translational component.
+ */
+ASSIMP_API void aiMatrix4DecomposeNoScaling(
+    const C_STRUCT aiMatrix4x4* mat,
+    C_STRUCT aiQuaternion* rotation,
+    C_STRUCT aiVector3D* position);
+
+// --------------------------------------------------------------------------------
+/** Creates a 4x4 matrix from a set of euler angles.
+ *  @param mat Receives the output matrix 
+ *  @param x Rotation angle for the x-axis, in radians
+ *  @param y Rotation angle for the y-axis, in radians
+ *  @param z Rotation angle for the z-axis, in radians
+ */
+ASSIMP_API void aiMatrix4FromEulerAngles(
+    C_STRUCT aiMatrix4x4* mat,
+    float x, float y, float z);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 rotation matrix around the X axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4RotationX(
+    C_STRUCT aiMatrix4x4* mat,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 rotation matrix around the Y axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4RotationY(
+    C_STRUCT aiMatrix4x4* mat,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 rotation matrix around the Z axis.
+ *  @param mat Receives the output matrix
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4RotationZ(
+    C_STRUCT aiMatrix4x4* mat,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Returns a 4x4 rotation matrix for a rotation around an arbitrary axis.
+ *  @param mat Receives the output matrix
+ *  @param axis Rotation axis, should be a normalized vector
+ *  @param angle Rotation angle, in radians
+ */
+ASSIMP_API void aiMatrix4FromRotationAroundAxis(
+    C_STRUCT aiMatrix4x4* mat,
+    const C_STRUCT aiVector3D* axis,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 translation matrix.
+ *  @param mat Receives the output matrix
+ *  @param translation The translation vector
+ */
+ASSIMP_API void aiMatrix4Translation(
+    C_STRUCT aiMatrix4x4* mat,
+    const C_STRUCT aiVector3D* translation);
+
+// --------------------------------------------------------------------------------
+/** Get a 4x4 scaling matrix.
+ *  @param mat Receives the output matrix
+ *  @param scaling The scaling vector
+ */
+ASSIMP_API void aiMatrix4Scaling(
+    C_STRUCT aiMatrix4x4* mat,
+    const C_STRUCT aiVector3D* scaling);
+
+// --------------------------------------------------------------------------------
+/** Create a 4x4 matrix that rotates one vector to another vector.
+ *  @param mat Receives the output matrix
+ *  @param from Vector to rotate from
+ *  @param to Vector to rotate to
+ */
+ASSIMP_API void aiMatrix4FromTo(
+    C_STRUCT aiMatrix4x4* mat,
+    const C_STRUCT aiVector3D* from,
+    const C_STRUCT aiVector3D* to);
+
+// --------------------------------------------------------------------------------
+/** Create a Quaternion from euler angles.
+ *  @param q Receives the output quaternion 
+ *  @param x Rotation angle for the x-axis, in radians
+ *  @param y Rotation angle for the y-axis, in radians
+ *  @param z Rotation angle for the z-axis, in radians
+ */
+ASSIMP_API void aiQuaternionFromEulerAngles(
+    C_STRUCT aiQuaternion* q,
+    float x, float y, float z);
+
+// --------------------------------------------------------------------------------
+/** Create a Quaternion from an axis angle pair.
+ *  @param q Receives the output quaternion
+ *  @param axis The orientation axis
+ *  @param angle The rotation angle, in radians
+ */
+ASSIMP_API void aiQuaternionFromAxisAngle(
+    C_STRUCT aiQuaternion* q,
+    const C_STRUCT aiVector3D* axis,
+    const float angle);
+
+// --------------------------------------------------------------------------------
+/** Create a Quaternion from a normalized quaternion stored
+ *  in a 3D vector.
+ *  @param q Receives the output quaternion
+ *  @param normalized The vector that stores the quaternion
+ */
+ASSIMP_API void aiQuaternionFromNormalizedQuaternion(
+    C_STRUCT aiQuaternion* q,
+    const C_STRUCT aiVector3D* normalized);
+
+// --------------------------------------------------------------------------------
+/** Check if quaternions are equal.
+ *  @param a First quaternion to compare
+ *  @param b Second quaternion to compare
+ *  @return 1 if the quaternions are equal
+ *  @return 0 if the quaternions are not equal
+ */
+ASSIMP_API int aiQuaternionAreEqual(
+    const C_STRUCT aiQuaternion* a,
+    const C_STRUCT aiQuaternion* b);
+
+// --------------------------------------------------------------------------------
+/** Check if quaternions are equal using epsilon.
+ *  @param a First quaternion to compare
+ *  @param b Second quaternion to compare
+ *  @param epsilon Epsilon
+ *  @return 1 if the quaternions are equal
+ *  @return 0 if the quaternions are not equal
+ */
+ASSIMP_API int aiQuaternionAreEqualEpsilon(
+    const C_STRUCT aiQuaternion* a,
+    const C_STRUCT aiQuaternion* b,
+    const float epsilon);
+
+// --------------------------------------------------------------------------------
+/** Normalize a quaternion.
+ *  @param q Quaternion to normalize
+ */
+ASSIMP_API void aiQuaternionNormalize(
+    C_STRUCT aiQuaternion* q);
+
+// --------------------------------------------------------------------------------
+/** Compute quaternion conjugate.
+ *  @param q Quaternion to compute conjugate,
+ *           receives the output quaternion
+ */
+ASSIMP_API void aiQuaternionConjugate(
+    C_STRUCT aiQuaternion* q);
+
+// --------------------------------------------------------------------------------
+/** Multiply quaternions.
+ *  @param dst First quaternion, receives the output quaternion
+ *  @param q Second quaternion
+ */
+ASSIMP_API void aiQuaternionMultiply(
+    C_STRUCT aiQuaternion* dst,
+    const C_STRUCT aiQuaternion* q);
+
+// --------------------------------------------------------------------------------
+/** Performs a spherical interpolation between two quaternions.
+ * @param dst Receives the quaternion resulting from the interpolation.
+ * @param start Quaternion when factor == 0
+ * @param end Quaternion when factor == 1
+ * @param factor Interpolation factor between 0 and 1
+ */
+ASSIMP_API void aiQuaternionInterpolate(
+    C_STRUCT aiQuaternion* dst,
+    const C_STRUCT aiQuaternion* start,
+    const C_STRUCT aiQuaternion* end,
+    const float factor);
+
 #ifdef __cplusplus
 }
 #endif

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,
@@ -100,13 +98,27 @@ struct aiMetadataEntry {
   */
 // -------------------------------------------------------------------------------
 
-inline aiMetadataType GetAiType( bool )       { return AI_BOOL; }
+inline aiMetadataType GetAiType(bool) {
-inline aiMetadataType GetAiType( int32_t )    { return AI_INT32; }
+    return AI_BOOL;
-inline aiMetadataType GetAiType( uint64_t )   { return AI_UINT64; }
+}
-inline aiMetadataType GetAiType( float )      { return AI_FLOAT; }
+inline aiMetadataType GetAiType(int32_t) {
-inline aiMetadataType GetAiType( double )     { return AI_DOUBLE; }
+    return AI_INT32;
-inline aiMetadataType GetAiType( const aiString & )   { return AI_AISTRING; }
+}
-inline aiMetadataType GetAiType( const aiVector3D & ) { return AI_AIVECTOR3D; }
+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
 
@@ -134,16 +146,14 @@ struct aiMetadata {
      *  @brief  The default constructor, set all members to zero by default.
      */
     aiMetadata() AI_NO_EXCEPT
-    : mNumProperties(0)
+            : mNumProperties(0),
-    , mKeys(nullptr)
+              mKeys(nullptr),
-    , mValues(nullptr) {
+              mValues(nullptr) {
         // empty
     }
 
-    aiMetadata( const aiMetadata &rhs )
+    aiMetadata(const aiMetadata &rhs) :
-    : mNumProperties( rhs.mNumProperties )
+            mNumProperties(rhs.mNumProperties), mKeys(nullptr), mValues(nullptr) {
-    , mKeys( nullptr )
-    , mValues( nullptr ) {
         mKeys = new aiString[mNumProperties];
         for (size_t i = 0; i < static_cast<size_t>(mNumProperties); ++i) {
             mKeys[i] = rhs.mKeys[i];
@@ -160,45 +170,38 @@ struct aiMetadata {
                 int32_t v;
                 ::memcpy(&v, rhs.mValues[i].mData, sizeof(int32_t));
                 mValues[i].mData = new int32_t(v);
-                }
+            } break;
-                break;
             case AI_UINT64: {
                 uint64_t v;
                 ::memcpy(&v, rhs.mValues[i].mData, sizeof(uint64_t));
                 mValues[i].mData = new uint64_t(v);
-                }
+            } break;
-                break;
             case AI_FLOAT: {
                 float v;
                 ::memcpy(&v, rhs.mValues[i].mData, sizeof(float));
                 mValues[i].mData = new float(v);
-                }
+            } break;
-                break;
             case AI_DOUBLE: {
                 double v;
                 ::memcpy(&v, rhs.mValues[i].mData, sizeof(double));
                 mValues[i].mData = new double(v);
-                }
+            } break;
-                break;
             case AI_AISTRING: {
                 aiString v;
                 rhs.Get<aiString>(mKeys[i], v);
                 mValues[i].mData = new aiString(v);
-                }
+            } break;
-                break;
             case AI_AIVECTOR3D: {
                 aiVector3D v;
                 rhs.Get<aiVector3D>(mKeys[i], v);
                 mValues[i].mData = new aiVector3D(v);
-                }
+            } break;
-                break;
 #ifndef SWIG
             case FORCE_32BIT:
 #endif
             default:
                 break;
             }
-
         }
     }
 
@@ -252,8 +255,7 @@ struct aiMetadata {
      *  @brief Allocates property fields + keys.
      *  @param  numProperties   Number of requested properties.
      */
-    static inline
+    static inline aiMetadata *Alloc(unsigned int numProperties) {
-    aiMetadata *Alloc( unsigned int numProperties ) {
         if (0 == numProperties) {
             return nullptr;
         }
@@ -269,19 +271,16 @@ struct aiMetadata {
     /**
      *  @brief Deallocates property fields + keys.
      */
-    static inline
+    static inline void Dealloc(aiMetadata *metadata) {
-    void Dealloc( aiMetadata *metadata ) {
         delete metadata;
     }
 
     template <typename T>
-	inline
+    inline void Add(const std::string &key, const T &value) {
-    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)
+        for (unsigned int i = 0; i < mNumProperties; ++i) {
-		{
             new_keys[i] = mKeys[i];
             new_values[i] = mValues[i];
         }
@@ -298,8 +297,7 @@ struct aiMetadata {
     }
 
     template <typename T>
-    inline 
+    inline bool Set(unsigned index, const std::string &key, const T &value) {
-    bool Set( unsigned index, const std::string& key, const T& value ) {
         // In range assertion
         if (index >= mNumProperties) {
             return false;
@@ -322,8 +320,25 @@ struct aiMetadata {
     }
 
     template <typename T>
-    inline 
+    inline bool Set( const std::string &key, const T &value ) {
-    bool Get( unsigned index, T& value ) const {
+        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 <typename T>
+    inline bool Get(unsigned index, T &value) const {
         // In range assertion
         if (index >= mNumProperties) {
             return false;
@@ -343,8 +358,7 @@ struct aiMetadata {
     }
 
     template <typename T>
-    inline 
+    inline bool Get(const aiString &key, T &value) const {
-    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) {
@@ -355,8 +369,7 @@ struct aiMetadata {
     }
 
     template <typename T>
-    inline
+    inline bool Get(const std::string &key, T &value) const {
-    bool Get( const std::string& key, T& value ) const {
         return Get(aiString(key), value);
     }
 
@@ -365,8 +378,7 @@ struct aiMetadata {
     /// \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
+    inline bool Get(size_t index, const aiString *&key, const aiMetadataEntry *&entry) const {
-    bool Get(size_t index, const aiString*& key, const aiMetadataEntry*& entry) const {
         if (index >= mNumProperties) {
             return false;
         }
@@ -379,8 +391,7 @@ struct aiMetadata {
 
     /// Check whether there is a metadata entry for the given key.
     /// \param [in] Key - the key value value to check for.
-    inline
+    inline bool HasKey(const char *key) {
-    bool HasKey(const char* key) {
         if (nullptr == key) {
             return false;
         }
@@ -395,7 +406,6 @@ struct aiMetadata {
     }
 
 #endif // __cplusplus
-
 };
 
 #endif // AI_METADATA_H_INC

include/assimp/quaternion.h

@@ -99,7 +99,7 @@ public:
     aiQuaterniont& Conjugate ();
 
     /** Rotate a point by this quaternion */
-    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in);
+    aiVector3t<TReal> Rotate (const aiVector3t<TReal>& in) const;
 
     /** Multiply two quaternions */
     aiQuaterniont operator* (const aiQuaterniont& two) const;

include/assimp/quaternion.inl

@@ -277,7 +277,7 @@ inline aiQuaterniont<TReal>& aiQuaterniont<TReal>::Conjugate ()
 
 // ---------------------------------------------------------------------------
 template<typename TReal>
-inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v)
+inline aiVector3t<TReal> aiQuaterniont<TReal>::Rotate (const aiVector3t<TReal>& v) const
 {
     aiQuaterniont q2(0.f,v.x,v.y,v.z), q = *this, qinv = q;
     qinv.Conjugate();

samples/SimpleOpenGL/Sample_SimpleOpenGL.c

@@ -278,7 +278,7 @@ void do_motion (void)
 	static int frames = 0;
 
 	int time = glutGet(GLUT_ELAPSED_TIME);
-	angle += (float)((time-prev_time)*0.01);
+	angle += static_cast<float>((time-prev_time)*0.01);
 	prev_time = time;
 
 	frames += 1;

samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h

@@ -31,40 +31,40 @@ struct Texture {
 
 class Mesh {
 public:
-    std::vector<VERTEX> vertices;
+    std::vector<VERTEX> vertices_;
-    std::vector<UINT> indices;
+    std::vector<UINT> indices_;
-    std::vector<Texture> textures;
+    std::vector<Texture> textures_;
-    ID3D11Device *dev;
+    ID3D11Device *dev_;
 
     Mesh(ID3D11Device *dev, const std::vector<VERTEX>& vertices, const std::vector<UINT>& indices, const std::vector<Texture>& textures) :
-            vertices(vertices),
+            vertices_(vertices),
-            indices(indices),
+            indices_(indices),
-            textures(textures),
+            textures_(textures),
-            dev(dev),
+            dev_(dev),
-            VertexBuffer(nullptr),
+            VertexBuffer_(nullptr),
-            IndexBuffer(nullptr) {
+            IndexBuffer_(nullptr) {
-        this->setupMesh(this->dev);
+        this->setupMesh(this->dev_);
     }
 
     void Draw(ID3D11DeviceContext *devcon) {
         UINT stride = sizeof(VERTEX);
         UINT offset = 0;
 
-        devcon->IASetVertexBuffers(0, 1, &VertexBuffer, &stride, &offset);
+        devcon->IASetVertexBuffers(0, 1, &VertexBuffer_, &stride, &offset);
-        devcon->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0);
+        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<UINT>(indices.size()), 0, 0);
+        devcon->DrawIndexed(static_cast<UINT>(indices_.size()), 0, 0);
     }
 
     void Close() {
-        SafeRelease(VertexBuffer);
+        SafeRelease(VertexBuffer_);
-        SafeRelease(IndexBuffer);
+        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<UINT>(sizeof(VERTEX) * vertices.size());
+        vbd.ByteWidth = static_cast<UINT>(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<UINT>(sizeof(UINT) * indices.size());
+        ibd.ByteWidth = static_cast<UINT>(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.");

samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp

@@ -1,12 +1,12 @@
 #include "ModelLoader.h"
 
 ModelLoader::ModelLoader() : 
-        dev(nullptr),
+        dev_(nullptr),
-        devcon(nullptr),
+        devcon_(nullptr),
-        meshes(),
+        meshes_(),
-        directory(),
+        directory_(),
-        textures_loaded(),
+        textures_loaded_(),
-        hwnd(nullptr) {
+        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->dev_ = dev;
-	this->devcon = devcon;
+	this->devcon_ = devcon;
-	this->hwnd = hwnd;
+	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 ) {
+	for (size_t i = 0; i < meshes_.size(); ++i ) {
-		meshes[i].Draw(devcon);
+		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<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, std::string typeName, const aiScene * scene) {
@@ -98,9 +98,9 @@ std::vector<Texture> 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++) {
+		for (UINT j = 0; j < textures_loaded_.size(); j++) {
-			if (std::strcmp(textures_loaded[j].path.c_str(), str.C_Str()) == 0) {
+			if (std::strcmp(textures_loaded_[j].path.c_str(), str.C_Str()) == 0) {
-				textures.push_back(textures_loaded[j]);
+				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<Texture> 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++) {
+	for (size_t i = 0; i < meshes_.size(); i++) {
-		meshes[i].Close();
+		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<int*>(&scene->mTextures[textureindex]->mWidth);
 
-	hr = CreateWICTextureFromMemory(dev, devcon, reinterpret_cast<unsigned char*>(scene->mTextures[textureindex]->pcData), *size, nullptr, &texture);
+	hr = CreateWICTextureFromMemory(dev_, devcon_, reinterpret_cast<unsigned char*>(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;
 }

samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h

@@ -25,12 +25,12 @@ public:
 
 	void Close();
 private:
-	ID3D11Device *dev;
+	ID3D11Device *dev_;
-	ID3D11DeviceContext *devcon;
+	ID3D11DeviceContext *devcon_;
-	std::vector<Mesh> meshes;
+	std::vector<Mesh> meshes_;
-	std::string directory;
+	std::string directory_;
-	std::vector<Texture> textures_loaded;
+	std::vector<Texture> textures_loaded_;
-	HWND hwnd;
+	HWND hwnd_;
 
 	void processNode(aiNode* node, const aiScene* scene);
 	Mesh processMesh(aiMesh* mesh, const aiScene* scene);

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,
+int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE /*hPrevInstance*/,
-	LPWSTR lpCmdLine, int nCmdShow)
+	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);
+	ShowWindow(g_hwnd, nCmdShow);
-	UpdateWindow(hwnd);
+	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<int>(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");
 }
 

samples/SimpleTexturedOpenGL/CMakeLists.txt

@@ -17,7 +17,6 @@ if ( MSVC )
 endif ()
 
 INCLUDE_DIRECTORIES(
-  ${Assimp_SOURCE_DIR}/include
   ${Assimp_SOURCE_DIR}/code
   ${OPENGL_INCLUDE_DIR}
   ${GLUT_INCLUDE_DIR}
@@ -30,7 +29,6 @@ LINK_DIRECTORIES(
 )
 
 ADD_EXECUTABLE( assimp_simpletexturedogl WIN32
-  SimpleTexturedOpenGL/include/boost_includes.h
   SimpleTexturedOpenGL/src/model_loading.cpp
   ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
   ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
@@ -47,3 +45,4 @@ SET_TARGET_PROPERTIES( assimp_simpletexturedogl PROPERTIES
 INSTALL( TARGETS assimp_simpletexturedogl
   DESTINATION "${ASSIMP_BIN_INSTALL_DIR}" COMPONENT assimp-dev
 )
+

samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/include/boost_includes.h

@@ -1 +0,0 @@
-#include <boost/lexical_cast.hpp>

samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp

@@ -18,8 +18,10 @@
 #include <GL/gl.h>
 #include <GL/glu.h>
 
+#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 <fstream>
 
@@ -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
+HGLRC       hRC=nullptr;            // Permanent Rendering Context
-HDC			hDC=NULL;			// Private GDI Device Context
+HDC         hDC=nullptr;            // Private GDI Device Context
-HWND		hWnd=NULL;			// Holds Window Handle
+HWND        g_hWnd=nullptr;         // Holds Window Handle
-HINSTANCE	hInstance;	// Holds The Instance Of The Application
+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?
+		if (!ReleaseDC(g_hWnd, hDC)) // Are We able to Release The DC?
-			MessageBox(NULL, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
-		hDC = NULL;
+		hDC = nullptr;
 	}
 
-	if (hWnd)
+	if (g_hWnd)
 	{
-		if (!DestroyWindow(hWnd)) // Are We Able To Destroy The Window
+		if (!DestroyWindow(g_hWnd)) // Are We Able To Destroy The Window
-			MessageBox(NULL, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
-		hWnd = NULL;
+		g_hWnd = nullptr;
 	} 
 
-	if (hInstance)
+	if (g_hInstance)
 	{
-		if (!UnregisterClass(TEXT("OpenGL"), hInstance)) // Are We Able To Unregister Class
+		if (!UnregisterClass(TEXT("OpenGL"), g_hInstance)) // Are We Able To Unregister Class
-			MessageBox(NULL, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+			MessageBox(nullptr, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
-		hInstance = NULL;
+		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.hInstance	= g_hInstance;
-	wc.hIcon		= LoadIcon(NULL, IDI_WINLOGO);	// Load The Default Icon
+	wc.hIcon		= LoadIcon(nullptr, IDI_WINLOGO);	// Load The Default Icon
-	wc.hCursor		= LoadCursor(NULL, IDC_ARROW);	// Load the default arrow
+	wc.hCursor		= LoadCursor(nullptr, IDC_ARROW);	// Load the default arrow
-	wc.hbrBackground= NULL;							// No Background required for OpenGL
+	wc.hbrBackground= nullptr;						// No Background required for OpenGL
-	wc.lpszMenuName	= NULL;							// No Menu
+	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
+								nullptr,						// No Parent Window
-								NULL,							// No Menu
+								nullptr,						// No Menu
-								hInstance,						// Instance
+								g_hInstance,					// Instance
-								NULL )))						// Don't pass anything To WM_CREATE
+								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
+	ShowWindow(g_hWnd, SW_SHOW);	// Show The Window
-	SetForegroundWindow(hWnd);		// Slightly Higher Prio
+	SetForegroundWindow(g_hWnd);	// Slightly Higher Prio
-	SetFocus(hWnd);					// Sets Keyboard Focus To The Window
+	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
+int WINAPI WinMain( HINSTANCE /*hInstance*/,     // The instance
-				   HINSTANCE hPrevInstance,      // Previous instance
+				   HINSTANCE /*hPrevInstance*/,  // Previous instance
-				   LPSTR lpCmdLine,              // Command Line Parameters
+				   LPSTR /*lpCmdLine*/,          // Command Line Parameters
-				   int nShowCmd )                // Window Show State
+				   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)
 			{

test/CMakeLists.txt

@@ -61,6 +61,14 @@ SET( COMMON
   unit/utIssues.cpp
   unit/utAnim.cpp
   unit/AssimpAPITest.cpp
+  unit/AssimpAPITest_aiMatrix3x3.cpp
+  unit/AssimpAPITest_aiMatrix4x4.cpp
+  unit/AssimpAPITest_aiQuaternion.cpp
+  unit/AssimpAPITest_aiVector2D.cpp
+  unit/AssimpAPITest_aiVector3D.cpp
+  unit/MathTest.cpp
+  unit/MathTest.h
+  unit/RandomNumberGeneration.h
   unit/utBatchLoader.cpp
   unit/utDefaultIOStream.cpp
   unit/utFastAtof.cpp
@@ -76,10 +84,12 @@ SET( COMMON
   unit/utProfiler.cpp
   unit/utSharedPPData.cpp
   unit/utStringUtils.cpp
+  unit/Common/uiScene.cpp
   unit/Common/utLineSplitter.cpp
 )
 
 SET( IMPORTERS
+  unit/ImportExport/Assxml/utAssxmlImportExport.cpp
   unit/utLWSImportExport.cpp
   unit/utLWOImportExport.cpp
   unit/utSMDImportExport.cpp
@@ -136,6 +146,9 @@ SET( IMPORTERS
   unit/ImportExport/MDL/utMDLImporter_HL1_ImportSettings.cpp
   unit/ImportExport/MDL/utMDLImporter_HL1_Materials.cpp
   unit/ImportExport/MDL/utMDLImporter_HL1_Nodes.cpp
+  #unit/ImportExport/IRR/utIrrImportExport.cpp
+  unit/ImportExport/RAW/utRAWImportExport.cpp
+  unit/ImportExport/Terragen/utTerragenImportExport.cpp
 )
 
 SET( MATERIAL

test/models/glTF2/TestNoRootNode/NoScene.gltf

@@ -0,0 +1,6 @@
+{
+    "asset": {
+        "version": "2.0"
+    },
+    "scene": 0
+}

test/models/glTF2/TestNoRootNode/SceneWithoutNodes.gltf

@@ -0,0 +1,10 @@
+{
+    "asset": {
+        "version": "2.0"
+    },
+    "scene": 0,
+    "scenes": [
+        {
+        }
+    ]
+}

test/unit/AssimpAPITest_aiMatrix3x3.cpp

@@ -0,0 +1,151 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+#include "MathTest.h"
+
+using namespace Assimp;
+
+class AssimpAPITest_aiMatrix3x3 : public AssimpMathTest {
+protected:
+    virtual void SetUp() {
+        result_c = result_cpp = aiMatrix3x3();
+    }
+
+    aiMatrix3x3 result_c, result_cpp;
+};
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiIdentityMatrix3Test) {
+    // Force a non-identity matrix.
+    result_c = aiMatrix3x3(0,0,0,0,0,0,0,0,0);
+    aiIdentityMatrix3(&result_c);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3FromMatrix4Test) {
+    const auto m = random_mat4();
+    result_cpp = aiMatrix3x3(m);
+    aiMatrix3FromMatrix4(&result_c, &m);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3FromQuaternionTest) {
+    const auto q = random_quat();
+    result_cpp = q.GetMatrix();
+    aiMatrix3FromQuaternion(&result_c, &q);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3AreEqualTest) {
+    result_c = result_cpp = random_mat3();
+    EXPECT_EQ(result_cpp == result_c,
+        (bool)aiMatrix3AreEqual(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3AreEqualEpsilonTest) {
+    result_c = result_cpp = random_mat3();
+    EXPECT_EQ(result_cpp.Equal(result_c, Epsilon),
+        (bool)aiMatrix3AreEqualEpsilon(&result_cpp, &result_c, Epsilon));
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMultiplyMatrix3Test) {
+    const auto m = random_mat3();
+    result_c = result_cpp = random_mat3();
+    result_cpp *= m;
+    aiMultiplyMatrix3(&result_c, &m);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiTransposeMatrix3Test) {
+    result_c = result_cpp = random_mat3();
+    result_cpp.Transpose();
+    aiTransposeMatrix3(&result_c);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3InverseTest) {
+    // Use a predetermined matrix to prevent arbitrary
+    // cases where it could have a null determinant.
+    result_c = result_cpp = aiMatrix3x3(
+        5, 2, 7,
+        4, 6, 9,
+        1, 8, 3);
+    result_cpp.Inverse();
+    aiMatrix3Inverse(&result_c);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3DeterminantTest) {
+    result_c = result_cpp = random_mat3();
+    EXPECT_EQ(result_cpp.Determinant(),
+        aiMatrix3Determinant(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3RotationZTest) {
+    const float angle(RandPI.next());
+    aiMatrix3x3::RotationZ(angle, result_cpp);
+    aiMatrix3RotationZ(&result_c, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3FromRotationAroundAxisTest) {
+    const float angle(RandPI.next());
+    const auto axis = random_unit_vec3();
+    aiMatrix3x3::Rotation(angle, axis, result_cpp);
+    aiMatrix3FromRotationAroundAxis(&result_c, &axis, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3TranslationTest) {
+    const auto axis = random_vec2();
+    aiMatrix3x3::Translation(axis, result_cpp);
+    aiMatrix3Translation(&result_c, &axis);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix3x3, aiMatrix3FromToTest) {
+    // Use predetermined vectors to prevent running into division by zero.
+    const auto from = aiVector3D(1,2,1).Normalize(), to = aiVector3D(-1,1,1).Normalize();
+    aiMatrix3x3::FromToMatrix(from, to, result_cpp);
+    aiMatrix3FromTo(&result_c, &from, &to);
+    EXPECT_EQ(result_cpp, result_c);
+}

test/unit/AssimpAPITest_aiMatrix4x4.cpp

@@ -0,0 +1,259 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+#include "MathTest.h"
+
+using namespace Assimp;
+
+class AssimpAPITest_aiMatrix4x4 : public AssimpMathTest {
+protected:
+    virtual void SetUp() {
+        result_c = result_cpp = aiMatrix4x4();
+    }
+
+    /* Generates a predetermined transformation matrix to use
+       for the aiDecompose functions to prevent running into
+       division by zero. */
+    aiMatrix4x4 get_predetermined_transformation_matrix_for_decomposition() const {
+        aiMatrix4x4 t, r;
+        aiMatrix4x4::Translation(aiVector3D(14,-25,-8), t);
+        aiMatrix4x4::Rotation(Math::PI<float>() / 4.0f, aiVector3D(1).Normalize(), r);
+        return t * r;
+    }
+
+    aiMatrix4x4 result_c, result_cpp;
+};
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiIdentityMatrix4Test) {
+    // Force a non-identity matrix.
+    result_c = aiMatrix4x4(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
+    aiIdentityMatrix4(&result_c);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4FromMatrix3Test) {
+    aiMatrix3x3 m = random_mat3();
+    result_cpp = aiMatrix4x4(m);
+    aiMatrix4FromMatrix3(&result_c, &m);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4FromScalingQuaternionPositionTest) {
+    const aiVector3D s = random_vec3();
+    const aiQuaternion q = random_quat();
+    const aiVector3D t = random_vec3();
+    result_cpp = aiMatrix4x4(s, q, t);
+    aiMatrix4FromScalingQuaternionPosition(&result_c, &s, &q, &t);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4AddTest) {
+    const aiMatrix4x4 temp = random_mat4();
+    result_c = result_cpp = random_mat4();
+    result_cpp = result_cpp + temp;
+    aiMatrix4Add(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4AreEqualTest) {
+    result_c = result_cpp = random_mat4();
+    EXPECT_EQ(result_cpp == result_c,
+        (bool)aiMatrix4AreEqual(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4AreEqualEpsilonTest) {
+    result_c = result_cpp = random_mat4();
+    EXPECT_EQ(result_cpp.Equal(result_c, Epsilon),
+        (bool)aiMatrix4AreEqualEpsilon(&result_cpp, &result_c, Epsilon));
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMultiplyMatrix4Test) {
+    const auto m = random_mat4();
+    result_c = result_cpp = random_mat4();
+    result_cpp *= m;
+    aiMultiplyMatrix4(&result_c, &m);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiTransposeMatrix4Test) {
+    result_c = result_cpp = random_mat4();
+    result_cpp.Transpose();
+    aiTransposeMatrix4(&result_c);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4InverseTest) {
+    // Use a predetermined matrix to prevent arbitrary
+    // cases where it could have a null determinant.
+    result_c = result_cpp = aiMatrix4x4(
+        6, 10, 15, 3,
+        14, 2, 12, 8,
+        9, 13, 5, 16,
+        4, 7, 11, 1);
+    result_cpp.Inverse();
+    aiMatrix4Inverse(&result_c);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4DeterminantTest) {
+    result_c = result_cpp = random_mat4();
+    EXPECT_EQ(result_cpp.Determinant(),
+        aiMatrix4Determinant(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4IsIdentityTest) {
+    EXPECT_EQ(result_cpp.IsIdentity(),
+        (bool)aiMatrix4IsIdentity(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiDecomposeMatrixTest) {
+    aiVector3D scaling_c, scaling_cpp,
+        position_c, position_cpp;
+    aiQuaternion rotation_c, rotation_cpp;
+
+    result_c = result_cpp = get_predetermined_transformation_matrix_for_decomposition();
+    result_cpp.Decompose(scaling_cpp, rotation_cpp, position_cpp);
+    aiDecomposeMatrix(&result_c, &scaling_c, &rotation_c, &position_c);
+    EXPECT_EQ(scaling_cpp, scaling_c);
+    EXPECT_EQ(position_cpp, position_c);
+    EXPECT_EQ(rotation_cpp, rotation_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4DecomposeIntoScalingEulerAnglesPositionTest) {
+    aiVector3D scaling_c, scaling_cpp,
+        rotation_c, rotation_cpp,
+        position_c, position_cpp;
+
+    result_c = result_cpp = get_predetermined_transformation_matrix_for_decomposition();
+    result_cpp.Decompose(scaling_cpp, rotation_cpp, position_cpp);
+    aiMatrix4DecomposeIntoScalingEulerAnglesPosition(&result_c, &scaling_c, &rotation_c, &position_c);
+    EXPECT_EQ(scaling_cpp, scaling_c);
+    EXPECT_EQ(position_cpp, position_c);
+    EXPECT_EQ(rotation_cpp, rotation_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4DecomposeIntoScalingAxisAnglePositionTest) {
+    aiVector3D scaling_c, scaling_cpp,
+        axis_c, axis_cpp,
+        position_c, position_cpp;
+    float angle_c, angle_cpp;
+
+    result_c = result_cpp = get_predetermined_transformation_matrix_for_decomposition();
+    result_cpp.Decompose(scaling_cpp, axis_cpp, angle_cpp, position_cpp);
+    aiMatrix4DecomposeIntoScalingAxisAnglePosition(&result_c, &scaling_c, &axis_c, &angle_c, &position_c);
+    EXPECT_EQ(scaling_cpp, scaling_c);
+    EXPECT_EQ(axis_cpp, axis_c);
+    EXPECT_EQ(angle_cpp, angle_c);
+    EXPECT_EQ(position_cpp, position_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4DecomposeNoScalingTest) {
+    aiVector3D position_c, position_cpp;
+    aiQuaternion rotation_c, rotation_cpp;
+
+    result_c = result_cpp = get_predetermined_transformation_matrix_for_decomposition();
+    result_cpp.DecomposeNoScaling(rotation_cpp, position_cpp);
+    aiMatrix4DecomposeNoScaling(&result_c, &rotation_c, &position_c);
+    EXPECT_EQ(position_cpp, position_c);
+    EXPECT_EQ(rotation_cpp, rotation_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4FromEulerAnglesTest) {
+    const float x(RandPI.next()),
+        y(RandPI.next()),
+        z(RandPI.next());
+    result_cpp.FromEulerAnglesXYZ(x, y, z);
+    aiMatrix4FromEulerAngles(&result_c, x, y, z);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4RotationXTest) {
+    const float angle(RandPI.next());
+    aiMatrix4x4::RotationX(angle, result_cpp);
+    aiMatrix4RotationX(&result_c, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4RotationYTest) {
+    const float angle(RandPI.next());
+    aiMatrix4x4::RotationY(angle, result_cpp);
+    aiMatrix4RotationY(&result_c, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4RotationZTest) {
+    const float angle(RandPI.next());
+    aiMatrix4x4::RotationZ(angle, result_cpp);
+    aiMatrix4RotationZ(&result_c, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4FromRotationAroundAxisTest) {
+    const float angle(RandPI.next());
+    const auto axis = random_unit_vec3();
+    aiMatrix4x4::Rotation(angle, axis, result_cpp);
+    aiMatrix4FromRotationAroundAxis(&result_c, &axis, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4TranslationTest) {
+    const auto axis = random_vec3();
+    aiMatrix4x4::Translation(axis, result_cpp);
+    aiMatrix4Translation(&result_c, &axis);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4ScalingTest) {
+    const auto scaling = random_vec3();
+    aiMatrix4x4::Scaling(scaling, result_cpp);
+    aiMatrix4Scaling(&result_c, &scaling);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiMatrix4x4, aiMatrix4FromToTest) {
+    // Use predetermined vectors to prevent running into division by zero.
+    const auto from = aiVector3D(1,2,1).Normalize(), to = aiVector3D(-1,1,1).Normalize();
+    aiMatrix4x4::FromToMatrix(from, to, result_cpp);
+    aiMatrix4FromTo(&result_c, &from, &to);
+    EXPECT_EQ(result_cpp, result_c);
+}

test/unit/AssimpAPITest_aiQuaternion.cpp

@@ -0,0 +1,135 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+#include "MathTest.h"
+
+using namespace Assimp;
+
+class AssimpAPITest_aiQuaternion : public AssimpMathTest {
+protected:
+    virtual void SetUp() {
+        result_c = result_cpp = aiQuaternion();
+    }
+
+    aiQuaternion result_c, result_cpp;
+};
+
+TEST_F(AssimpAPITest_aiQuaternion, aiCreateQuaternionFromMatrixTest) {
+    // Use a predetermined transformation matrix
+    // to prevent running into division by zero.
+    aiMatrix3x3 m, r;
+    aiMatrix3x3::Translation(aiVector2D(14,-25), m);
+    aiMatrix3x3::RotationZ(Math::PI<float>() / 4.0f, r);
+    m = m * r;
+
+    result_cpp = aiQuaternion(m);
+    aiCreateQuaternionFromMatrix(&result_c, &m);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionFromEulerAnglesTest) {
+    const float x(RandPI.next()),
+        y(RandPI.next()),
+        z(RandPI.next());
+    result_cpp = aiQuaternion(x, y, z);
+    aiQuaternionFromEulerAngles(&result_c, x, y, z);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionFromAxisAngleTest) {
+    const float angle(RandPI.next());
+    const aiVector3D axis(random_unit_vec3());
+    result_cpp = aiQuaternion(axis, angle);
+    aiQuaternionFromAxisAngle(&result_c, &axis, angle);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionFromNormalizedQuaternionTest) {
+    const auto qvec3 = random_unit_vec3();
+    result_cpp = aiQuaternion(qvec3);
+    aiQuaternionFromNormalizedQuaternion(&result_c, &qvec3);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionAreEqualTest) {
+    result_c = result_cpp = random_quat();
+    EXPECT_EQ(result_cpp == result_c,
+        (bool)aiQuaternionAreEqual(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionAreEqualEpsilonTest) {
+    result_c = result_cpp = random_quat();
+    EXPECT_EQ(result_cpp.Equal(result_c, Epsilon),
+        (bool)aiQuaternionAreEqualEpsilon(&result_cpp, &result_c, Epsilon));
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionNormalizeTest) {
+    result_c = result_cpp = random_quat();
+    aiQuaternionNormalize(&result_c);
+    EXPECT_EQ(result_cpp.Normalize(), result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionConjugateTest) {
+    result_c = result_cpp = random_quat();
+    aiQuaternionConjugate(&result_c);
+    EXPECT_EQ(result_cpp.Conjugate(), result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionMultiplyTest) {
+    const aiQuaternion temp = random_quat();
+    result_c = result_cpp = random_quat();
+    result_cpp = result_cpp * temp;
+    aiQuaternionMultiply(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiQuaternion, aiQuaternionInterpolateTest) {
+    // Use predetermined quaternions to prevent division by zero
+    // during slerp calculations.
+    const float INTERPOLATION(0.5f);
+    const auto q1 = aiQuaternion(aiVector3D(-1,1,1).Normalize(), Math::PI<float>() / 4.0f);
+    const auto q2 = aiQuaternion(aiVector3D(1,2,1).Normalize(), Math::PI<float>() / 2.0f);
+    aiQuaternion::Interpolate(result_cpp, q1, q2, INTERPOLATION);
+    aiQuaternionInterpolate(&result_c, &q1, &q2, INTERPOLATION);
+    EXPECT_EQ(result_cpp, result_c);
+}

test/unit/AssimpAPITest_aiVector2D.cpp

@@ -0,0 +1,140 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+#include "MathTest.h"
+
+using namespace Assimp;
+
+class AssimpAPITest_aiVector2D : public AssimpMathTest {
+protected:
+    virtual void SetUp() {
+        result_c = result_cpp = aiVector2D();
+        temp = random_vec2(); // Generates a random 2D vector != null vector.
+    }
+
+    aiVector2D result_c, result_cpp, temp;
+};
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2AreEqualTest) {
+    result_c = result_cpp = random_vec2();
+    EXPECT_EQ(result_cpp == result_c,
+        (bool)aiVector2AreEqual(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2AreEqualEpsilonTest) {
+    result_c = result_cpp = random_vec2();
+    EXPECT_EQ(result_cpp.Equal(result_c, Epsilon),
+        (bool)aiVector2AreEqualEpsilon(&result_cpp, &result_c, Epsilon));
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2AddTest) {
+    result_c = result_cpp = random_vec2();
+    result_cpp += temp;
+    aiVector2Add(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2SubtractTest) {
+    result_c = result_cpp = random_vec2();
+    result_cpp -= temp;
+    aiVector2Subtract(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2ScaleTest) {
+    const float FACTOR = RandNonZero.next();
+    result_c = result_cpp = random_vec2();
+    result_cpp *= FACTOR;
+    aiVector2Scale(&result_c, FACTOR);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2SymMulTest) {
+    result_c = result_cpp = random_vec2();
+    result_cpp = result_cpp.SymMul(temp);
+    aiVector2SymMul(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2DivideByScalarTest) {
+    const float DIVISOR = RandNonZero.next();
+    result_c = result_cpp = random_vec2();
+    result_cpp /= DIVISOR;
+    aiVector2DivideByScalar(&result_c, DIVISOR);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2DivideByVectorTest) {
+    result_c = result_cpp = random_vec2();
+    result_cpp = result_cpp / temp;
+    aiVector2DivideByVector(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2LengthTest) {
+    result_c = result_cpp = random_vec2();
+    EXPECT_EQ(result_cpp.Length(), aiVector2Length(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2SquareLengthTest) {
+    result_c = result_cpp = random_vec2();
+    EXPECT_EQ(result_cpp.SquareLength(), aiVector2SquareLength(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2NegateTest) {
+    result_c = result_cpp = random_vec2();
+    aiVector2Negate(&result_c);
+    EXPECT_EQ(-result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2DotProductTest) {
+    result_c = result_cpp = random_vec2();
+    EXPECT_EQ(result_cpp * result_c,
+        aiVector2DotProduct(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector2D, aiVector2NormalizeTest) {
+    result_c = result_cpp = random_vec2();
+    aiVector2Normalize(&result_c);
+    EXPECT_EQ(result_cpp.Normalize(), result_c);
+}

test/unit/AssimpAPITest_aiVector3D.cpp

@@ -0,0 +1,185 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "UnitTestPCH.h"
+#include "MathTest.h"
+
+using namespace Assimp;
+
+class AssimpAPITest_aiVector3D : public AssimpMathTest {
+protected:
+    virtual void SetUp() {
+        result_c = result_cpp = aiVector3D();
+        temp = random_vec3(); // Generates a random 3D vector != null vector.
+    }
+
+    aiVector3D result_c, result_cpp, temp;
+};
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3AreEqualTest) {
+    result_c = result_cpp = random_vec3();
+    EXPECT_EQ(result_cpp == result_c,
+        (bool)aiVector3AreEqual(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3AreEqualEpsilonTest) {
+    result_c = result_cpp = random_vec3();
+    EXPECT_EQ(result_cpp.Equal(result_c, Epsilon),
+        (bool)aiVector3AreEqualEpsilon(&result_cpp, &result_c, Epsilon));
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3LessThanTest) {
+    result_c = result_cpp = random_vec3();
+    EXPECT_EQ(result_cpp < temp,
+        (bool)aiVector3LessThan(&result_c, &temp));
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3AddTest) {
+    result_c = result_cpp = random_vec3();
+    result_cpp += temp;
+    aiVector3Add(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3SubtractTest) {
+    result_c = result_cpp = random_vec3();
+    result_cpp -= temp;
+    aiVector3Subtract(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3ScaleTest) {
+    const float FACTOR = RandNonZero.next();
+    result_c = result_cpp = random_vec3();
+    result_cpp *= FACTOR;
+    aiVector3Scale(&result_c, FACTOR);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3SymMulTest) {
+    result_c = result_cpp = random_vec3();
+    result_cpp = result_cpp.SymMul(temp);
+    aiVector3SymMul(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3DivideByScalarTest) {
+    const float DIVISOR = RandNonZero.next();
+    result_c = result_cpp = random_vec3();
+    result_cpp /= DIVISOR;
+    aiVector3DivideByScalar(&result_c, DIVISOR);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3DivideByVectorTest) {
+    result_c = result_cpp = random_vec3();
+    result_cpp = result_cpp / temp;
+    aiVector3DivideByVector(&result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3LengthTest) {
+    result_c = result_cpp = random_vec3();
+    EXPECT_EQ(result_cpp.Length(), aiVector3Length(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3SquareLengthTest) {
+    result_c = result_cpp = random_vec3();
+    EXPECT_EQ(result_cpp.SquareLength(), aiVector3SquareLength(&result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3NegateTest) {
+    result_c = result_cpp = random_vec3();
+    aiVector3Negate(&result_c);
+    EXPECT_EQ(-result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3DotProductTest) {
+    result_c = result_cpp = random_vec3();
+    EXPECT_EQ(result_cpp * result_c,
+        aiVector3DotProduct(&result_cpp, &result_c));
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3CrossProductTest) {
+    result_c = result_cpp = random_vec3();
+    result_cpp = result_cpp ^ temp;
+    aiVector3CrossProduct(&result_c, &result_c, &temp);
+    EXPECT_EQ(result_cpp, result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3NormalizeTest) {
+    result_c = result_cpp = random_vec3();
+    aiVector3Normalize(&result_c);
+    EXPECT_EQ(result_cpp.Normalize(), result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3NormalizeSafeTest) {
+    result_c = result_cpp = random_vec3();
+    aiVector3NormalizeSafe(&result_c);
+    EXPECT_EQ(result_cpp.NormalizeSafe(), result_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiVector3RotateByQuaternionTest) {
+    aiVector3D v_c, v_cpp;
+    v_c = v_cpp = random_vec3();
+    const auto q = random_quat();
+    aiVector3RotateByQuaternion(&v_c, &q);
+    EXPECT_EQ(q.Rotate(v_cpp), v_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiTransformVecByMatrix3Test) {
+    const auto m = random_mat3();
+    aiVector3D v_c, v_cpp;
+    v_c = v_cpp = random_vec3();
+    v_cpp *= m;
+    aiTransformVecByMatrix3(&v_c, &m);
+    EXPECT_EQ(v_cpp, v_c);
+}
+
+TEST_F(AssimpAPITest_aiVector3D, aiTransformVecByMatrix4Test) {
+    const auto m = random_mat4();
+    aiVector3D v_c, v_cpp;
+    v_c = v_cpp = random_vec3();
+    v_cpp *= m;
+    aiTransformVecByMatrix4(&v_c, &m);
+    EXPECT_EQ(v_cpp, v_c);
+}

test/unit/Common/uiScene.cpp

@@ -0,0 +1,93 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#include "UnitTestPCH.h"
+
+#include <assimp/scene.h>
+
+
+using namespace Assimp;
+
+class utScene : public ::testing::Test {
+protected:
+	aiScene *scene;
+
+    void SetUp() override {
+		scene = new aiScene;
+    }
+
+    void TearDown() override {
+		delete scene;
+		scene = nullptr;
+    }
+};
+
+TEST_F(utScene, findNodeTest) {
+	scene->mRootNode = new aiNode();
+	scene->mRootNode->mName.Set("test");
+	aiNode *child = new aiNode;
+	child->mName.Set("child");
+	scene->mRootNode->addChildren(1, &child);
+	aiNode *found = scene->mRootNode->FindNode("child");
+	EXPECT_EQ(child, found);
+}
+
+TEST_F(utScene, sceneHasContentTest) {
+    EXPECT_FALSE(scene->HasAnimations());
+	EXPECT_FALSE(scene->HasMaterials());
+	EXPECT_FALSE(scene->HasMeshes());
+	EXPECT_FALSE(scene->HasCameras());
+	EXPECT_FALSE(scene->HasLights());
+	EXPECT_FALSE(scene->HasTextures());
+}
+
+TEST_F(utScene, getShortFilenameTest) {
+	std::string long_filename1 = "foo_bar/name";
+    const char *name1 = scene->GetShortFilename(long_filename1.c_str());
+	EXPECT_NE(nullptr, name1);
+
+    std::string long_filename2 = "foo_bar\\name";
+    const char *name2 = scene->GetShortFilename(long_filename2.c_str());
+	EXPECT_NE(nullptr, name2);
+}
+
+TEST_F(utScene, getEmbeddedTextureTest) {
+}

test/unit/ImportExport/Assxml/utAssxmlImportExport.cpp

@@ -0,0 +1,76 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2019, assimp team
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#include "AbstractImportExportBase.h"
+#include "SceneDiffer.h"
+#include "UnitTestPCH.h"
+
+#include <assimp/postprocess.h>
+#include <assimp/Importer.hpp>
+#include <assimp/Exporter.hpp>
+
+using namespace Assimp;
+
+class utAssxmlImportExport : public AbstractImportExportBase {
+public:
+	bool importerTest() override {
+		return true;
+    }
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+	bool exporterTest() override {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/OBJ/spider.obj", aiProcess_ValidateDataStructure);
+		EXPECT_NE(scene, nullptr );
+
+        ::Assimp::Exporter exporter;
+		return AI_SUCCESS == exporter.Export(scene, "assxml", ASSIMP_TEST_MODELS_DIR "/OBJ/spider_out.assxml");
+    }
+#endif
+};
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+
+TEST_F(utAssxmlImportExport, exportAssxmlTest) {
+	EXPECT_TRUE(exporterTest());
+}
+
+#endif

test/unit/ImportExport/IRR/utIrrImportExport.cpp

@@ -0,0 +1,66 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "AbstractImportExportBase.h"
+#include "UnitTestPCH.h"
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+using namespace Assimp;
+
+class utIrrImportExport : public AbstractImportExportBase {
+public:
+	virtual bool importerTest() {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/IRR/box.irr", aiProcess_ValidateDataStructure);
+		return nullptr != scene;
+	}
+};
+
+TEST_F(utIrrImportExport, importSimpleIrrTest) {
+	EXPECT_TRUE(importerTest());
+}
+
+TEST_F(utIrrImportExport, importSGIrrTest) {
+	Assimp::Importer importer;
+	const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/IRR/dawfInCellar_SameHierarchy.irr", aiProcess_ValidateDataStructure);
+	EXPECT_NE( nullptr,scene);
+}

test/unit/ImportExport/RAW/utRAWImportExport.cpp

@@ -0,0 +1,64 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "AbstractImportExportBase.h"
+#include "UnitTestPCH.h"
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+using namespace Assimp;
+
+class utRAWImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/RAW/Wuson.raw", aiProcess_ValidateDataStructure);
+#ifndef ASSIMP_BUILD_NO_RAW_IMPORTER
+        return nullptr != scene;
+#else
+        return nullptr == scene;
+#endif
+    }
+};
+
+TEST_F(utRAWImportExport, importSimpleRAWTest) {
+    EXPECT_TRUE(importerTest());
+}

test/unit/ImportExport/Terragen/utTerragenImportExport.cpp

@@ -0,0 +1,60 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#include "AbstractImportExportBase.h"
+#include "UnitTestPCH.h"
+
+#include <assimp/postprocess.h>
+#include <assimp/Importer.hpp>
+
+class utTerragenImportExport : public AbstractImportExportBase {
+public:
+    virtual bool importerTest() {
+        /*Assimp::Importer importer;
+        const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/TER/RealisticTerrain.ter", aiProcess_ValidateDataStructure);
+        return nullptr != scene;*/
+        return true;
+    }
+};
+
+TEST_F(utTerragenImportExport, importX3DFromFileTest) {
+    EXPECT_TRUE(importerTest());
+}

test/unit/ImportExport/utCOBImportExport.cpp

@@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/ImportExport/utOFFImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>

test/unit/ImportExport/utOgreImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/ImportExport/utQ3BSPFileImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/MathTest.cpp

@@ -0,0 +1,56 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+#include "MathTest.h"
+
+namespace Assimp {
+
+// Initialize epsilon value.
+const float AssimpMathTest::Epsilon = Math::getEpsilon<float>();
+
+// Initialize with an interval of [1,100].
+RandomUniformFloatGenerator AssimpMathTest::RandNonZero(1.0f, 100.0f);
+
+// Initialize with an interval of [-PI,PI] inclusively.
+RandomUniformFloatGenerator AssimpMathTest::RandPI(-Math::PI<float>(), Math::PI<float>());
+
+}

test/unit/MathTest.h

@@ -0,0 +1,103 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_MATH_TEST_H
+#define ASSIMP_MATH_TEST_H
+
+#include "UnitTestPCH.h"
+#include <assimp/types.h>
+#include "RandomNumberGeneration.h"
+
+namespace Assimp {
+
+/** Custom test class providing several math related utilities. */
+class AssimpMathTest : public ::testing::Test {
+public:
+    /** Return a random non-null 2D vector. */
+    inline static aiVector2D random_vec2() {
+        return aiVector2D(RandNonZero.next(), RandNonZero.next());
+    }
+
+    /** Return a random non-null 3D vector. */
+    inline static aiVector3D random_vec3() {
+        return aiVector3D(RandNonZero.next(), RandNonZero.next(),RandNonZero.next());
+    }
+
+    /** Return a random unit 3D vector. */
+    inline static aiVector3D random_unit_vec3() {
+        return random_vec3().NormalizeSafe();
+    }
+
+    /** Return a quaternion with random orientation and
+      * rotation angle around axis. */
+    inline static aiQuaternion random_quat() {
+        return aiQuaternion(random_unit_vec3(), RandPI.next());
+    }
+
+    /** Return a random non-null 3x3 matrix. */
+    inline static aiMatrix3x3 random_mat3() {
+        return aiMatrix3x3(
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next(),
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next(),
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next());
+    }
+
+    /** Return a random non-null 4x4 matrix. */
+    inline static aiMatrix4x4 random_mat4() {
+        return aiMatrix4x4(
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next(), RandNonZero.next(),
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next(), RandNonZero.next(),
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next(), RandNonZero.next(),
+            RandNonZero.next(), RandNonZero.next(),RandNonZero.next(), RandNonZero.next());
+    }
+
+    /** Epsilon value to use in tests. */
+    static const float Epsilon;
+
+    /** Random number generators. */
+    static RandomUniformFloatGenerator RandNonZero, RandPI;
+};
+
+}
+
+#endif // ASSIMP_MATH_TEST_H

test/unit/RandomNumberGeneration.h

@@ -0,0 +1,82 @@
+/*
+---------------------------------------------------------------------------
+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,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#ifndef ASSIMP_RANDOM_NUMBER_GENERATION_H
+#define ASSIMP_RANDOM_NUMBER_GENERATION_H
+
+#include <random>
+
+namespace Assimp {
+
+/** Helper class to use for generating pseudo-random
+ *  real numbers, with a uniform distribution. */
+template<typename T>
+class RandomUniformRealGenerator {
+public:
+    RandomUniformRealGenerator() :
+            dist_(),
+            rd_(), 
+            re_(rd_())  {
+        // empty
+    }
+    
+    RandomUniformRealGenerator(T min, T max) :
+            dist_(min, max),
+            rd_(),
+            re_(rd_())  {
+        // empty
+    }
+
+    inline T next() {
+        return dist_(re_);
+    }
+
+private:
+    std::uniform_real_distribution<T> dist_;
+    std::random_device rd_;
+    std::default_random_engine re_;
+};
+
+using RandomUniformFloatGenerator = RandomUniformRealGenerator<float>;
+
+}
+
+#endif // ASSIMP_RANDOM_NUMBER_GENERATION_H

test/unit/ut3DSImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utAMFImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utASEImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utArmaturePopulate.cpp

@@ -42,7 +42,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "UnitTestPCH.h"
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 
 #include <assimp/material.h>
 #include <assimp/postprocess.h>

test/unit/utAssbinImportExport.cpp

@@ -39,7 +39,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ---------------------------------------------------------------------------
 */
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 #include <assimp/postprocess.h>
 #include <assimp/Exporter.hpp>

test/unit/utB3DImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utDXFImporterExporter.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utFBXImporterExporter.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/commonMetaData.h>
@@ -214,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) {

test/unit/utM3DImportExport.cpp

@@ -41,9 +41,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
+#include <assimp/Importer.hpp>
+#include <assimp/Exporter.hpp>
 #include <assimp/postprocess.h>
 #include <assimp/Importer.hpp>
 
@@ -51,7 +52,7 @@ using namespace Assimp;
 
 class utM3DImportExport : public AbstractImportExportBase {
 public:
-    virtual bool importerTest() {
+	bool importerTest() override  {
         Assimp::Importer importer;
         const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/M3D/cube_normals.m3d", aiProcess_ValidateDataStructure);
 #ifndef ASSIMP_BUILD_NO_M3D_IMPORTER
@@ -60,8 +61,24 @@ public:
         return nullptr == scene;
 #endif // ASSIMP_BUILD_NO_M3D_IMPORTER
     }
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+    bool exporterTest() override {
+		Assimp::Importer importer;
+		const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/M3D/cube_normals.m3d", aiProcess_ValidateDataStructure);
+		Exporter exporter;
+		aiReturn ret = exporter.Export(scene, "m3d", ASSIMP_TEST_MODELS_DIR "/M3D/cube_normals_out.m3d");
+		return ret == AI_SUCCESS;
+    }
+#endif
 };
 
 TEST_F(utM3DImportExport, importM3DFromFileTest) {
     EXPECT_TRUE(importerTest());
 }
+
+#ifndef ASSIMP_BUILD_NO_EXPORT
+TEST_F(utM3DImportExport, exportM3DFromFileTest) {
+	EXPECT_TRUE(exporterTest());
+}
+#endif //  ASSIMP_BUILD_NO_EXPORT

test/unit/utPMXImporter.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "UnitTestPCH.h"
-#include "SceneDiffer.h"
 #include "AbstractImportExportBase.h"
 #include "MMD/MMDImporter.h"
 

test/unit/utSTLImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utX3DImportExport.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utXImporterExporter.cpp

@@ -40,7 +40,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "AbstractImportExportBase.h"
-#include "SceneDiffer.h"
 #include "UnitTestPCH.h"
 
 #include <assimp/postprocess.h>

test/unit/utglTF2ImportExport.cpp

@@ -490,3 +490,16 @@ TEST_F(utglTF2ImportExport, texcoords) {
     EXPECT_EQ(aiGetMaterialInteger(material, AI_MATKEY_GLTF_TEXTURE_TEXCOORD(aiTextureType_UNKNOWN, 0), &uvIndex), aiReturn_SUCCESS);
     EXPECT_EQ(uvIndex, 1);
 }
+
+TEST_F(utglTF2ImportExport, norootnode_noscene) {
+    Assimp::Importer importer;
+    const aiScene* scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/glTF2/TestNoRootNode/NoScene.gltf", aiProcess_ValidateDataStructure);
+    ASSERT_EQ(scene, nullptr);
+}
+
+TEST_F(utglTF2ImportExport, norootnode_scenewithoutnodes) {
+    Assimp::Importer importer;
+    const aiScene* scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/glTF2/TestNoRootNode/SceneWithoutNodes.gltf", aiProcess_ValidateDataStructure);
+    ASSERT_NE(scene, nullptr);
+    ASSERT_NE(scene->mRootNode, nullptr);
+}

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,
+            nullptr,
-            NULL,
+            nullptr,
             (IDirect3DCubeTexture9**)&pcTexture)))
         {
             const char* szEnd = strrchr(szPath.c_str(),'\\');
@@ -411,8 +411,8 @@ void CBackgroundPainter::RecreateNativeResource()
             D3DX_DEFAULT,
             D3DX_DEFAULT,
             0,
-            NULL,
+            nullptr,
-            NULL,
+            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,
+            nullptr,
-            NULL,
+            nullptr,
             AI_SHADER_COMPILE_FLAGS,
-            NULL,
+            nullptr,
             &piSkyBoxEffect,&piBuffer)))
         {
             // failed to compile the shader

tools/assimp_view/Display.cpp

@@ -158,8 +158,8 @@ int CDisplay::AddNodeToDisplayList(
     aiNode* pcNode,
     HTREEITEM hRoot)
 {
-    ai_assert(NULL != pcNode);
+    ai_assert(nullptr != pcNode);
-    ai_assert(NULL != hRoot);
+    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<ai_uint32>(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;
+        IDirect3DTexture9** tex = nullptr;
-        const char* tex_string  = NULL;
+        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);
+            int iIndex2 = atoi(szPath->data+1);
-            ai_snprintf(chTempEmb,256,"Embedded #%i",iIndex);
+            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_LCOLOR1),nullptr,TRUE);
-    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),NULL,TRUE);
+    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR2),nullptr,TRUE);
-    InvalidateRect(GetDlgItem(g_hDlg,IDC_LCOLOR3),NULL,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_pcCurrentMaterial = nullptr;
-    m_pcCurrentTexture = NULL;
+    m_pcCurrentTexture = nullptr;
-    m_pcCurrentNode = NULL;
+    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<TextureInfo>::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<TextureInfo>::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<MaterialInfo>::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<unsigned char>(clrOld.g * 255.0f),
             clamp<unsigned char>(clrOld.b * 255.0f));
         clr.lpCustColors = g_aclCustomColors;
-        clr.lpfnHook = NULL;
+        clr.lpfnHook = nullptr;
-        clr.lpTemplateName = NULL;
+        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,
+            nullptr, 0, 1,
-            szFileName, MAX_PATH, NULL, 0, NULL,
+            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),
+            g_hDlg,GetModuleHandle(nullptr),
-            "Textures\0*.png;*.dds;*.bmp;*.tif;*.pfm;*.jpg;*.jpeg;*.hdr\0*.*\0", NULL, 0, 1,
+            "Textures\0*.png;*.dds;*.bmp;*.tif;*.pfm;*.jpg;*.jpeg;*.hdr\0*.*\0", nullptr, 0, 1,
-            szFileName, MAX_PATH, NULL, 0, NULL,
+            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,
+                nullptr,
-                NULL,
+                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 ...

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");
+            HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_TEXT1),"TEXT");
-            HGLOBAL hg = LoadResource(NULL,res);
+            HGLOBAL hg = LoadResource(nullptr,res);
             void* pData = LockResource(hg);
 
             SETTEXTEX sInfo;

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;

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),
+        g_hDlg,GetModuleHandle(nullptr),
-        "Log files\0*.txt", NULL, 0, 1,
+        "Log files\0*.txt", nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        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;
 

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<ai_uint32>(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<ai_uint32>(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<ai_uint32>(strlen(tmp2));
                             return 1;
                         }
                     }
@@ -402,23 +402,22 @@ int CMaterialManager::FindValidPath(aiString* p_szString)
         }
         fclose(pFile);
 
-        // copy the result string back to the aiString
+        // copy the result string back to the aiStr
-        const size_t iLen = strlen(szTemp);
+        const size_t len = strlen(szTemp);
-        size_t iLen2 = iLen+1;
+        size_t len2 = len+1;
-        iLen2 = iLen2 > MAXLEN ? MAXLEN : iLen2;
+        len2 = len2 > MAXLEN ? MAXLEN : len2;
-        memcpy(p_szString->data,szTemp,iLen2);
+        memcpy(p_szString->data, szTemp, len2);
-        p_szString->length = iLen;
+        p_szString->length = static_cast<ai_uint32>(len);
-
     }
     return 1;
 }
 //-------------------------------------------------------------------------------
 int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
 {
-    ai_assert(NULL != p_ppiOut);
+    ai_assert(nullptr != p_ppiOut);
-    ai_assert(NULL != szPath);
+    ai_assert(nullptr != szPath);
 
-    *p_ppiOut = NULL;
+    *p_ppiOut = nullptr;
 
     const std::string s = szPath->data;
     TextureCache::iterator ff;
@@ -453,7 +452,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 +469,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 +481,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 +523,8 @@ int CMaterialManager::LoadTexture(IDirect3DTexture9** p_ppiOut,aiString* szPath)
         D3DX_DEFAULT,
         D3DX_DEFAULT,
         0,
-        NULL,
+        nullptr,
-        NULL,
+        nullptr,
         p_ppiOut)))
     {
         // error ... use the default texture instead
@@ -550,44 +549,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 +594,8 @@ void CMaterialManager::HMtoNMIfNecessary(
     IDirect3DTexture9** piTextureOut,
     bool bWasOriginallyHM)
 {
-    ai_assert(NULL != piTexture);
+    ai_assert(nullptr != piTexture);
-    ai_assert(NULL != piTextureOut);
+    ai_assert(nullptr != piTextureOut);
 
     bool bMustConvert = false;
     uintptr_t iElement = 3;
@@ -617,7 +616,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 +626,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 +645,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 +704,9 @@ void CMaterialManager::HMtoNMIfNecessary(
                     aiColor3D clrColorLine;
                     for (unsigned int x = 0; x <  sDesc.Width;++x)
                     {
-                        clrColorLine.r += pcPointer->r;
+                        clrColorLine.r += pcPointer->data.r;
-                        clrColorLine.g += pcPointer->g;
+                        clrColorLine.g += pcPointer->data.g;
-                        clrColorLine.b += pcPointer->b;
+                        clrColorLine.b += pcPointer->data.b;
                         pcPointer++;
                     }
                     clrColor.r += clrColorLine.r /= (float)sDesc.Width;
@@ -739,17 +738,17 @@ void CMaterialManager::HMtoNMIfNecessary(
     // need to convert it NOW
     if (bMustConvert)
     {
-        D3DSURFACE_DESC sDesc;
+        D3DSURFACE_DESC sDesc2;
-        piTexture->GetLevelDesc(0, &sDesc);
+        piTexture->GetLevelDesc(0, &sDesc2);
 
         IDirect3DTexture9* piTempTexture;
         if(FAILED(g_piDevice->CreateTexture(
-            sDesc.Width,
+            sDesc2.Width,
-            sDesc.Height,
+            sDesc2.Height,
             piTexture->GetLevelCount(),
-            sDesc.Usage,
+            sDesc2.Usage,
-            sDesc.Format,
+            sDesc2.Format,
-            sDesc.Pool, &piTempTexture, NULL)))
+            sDesc2.Pool, &piTempTexture, nullptr)))
         {
             CLogDisplay::Instance().AddEntry(
                 "[ERROR] Unable to create normal map texture",
@@ -764,7 +763,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 +779,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 +822,8 @@ bool CMaterialManager::HasAlphaPixels(IDirect3DTexture9* piTexture)
 int CMaterialManager::CreateMaterial(
     AssetHelper::MeshHelper* pcMesh,const aiMesh* pcSource)
 {
-    ai_assert(NULL != pcMesh);
+    ai_assert(nullptr != pcMesh);
-    ai_assert(NULL != pcSource);
+    ai_assert(nullptr != pcSource);
 
     ID3DXBuffer* piBuffer;
 
@@ -1060,29 +1059,29 @@ int CMaterialManager::CreateMaterial(
         }
         AssetHelper::MeshHelper* pc = g_pcAsset->apcMeshes[i];
 
-        if  ((pcMesh->piDiffuseTexture != NULL ? true : false) !=
+        if  ((pcMesh->piDiffuseTexture != nullptr ? true : false) !=
-            (pc->piDiffuseTexture != NULL ? true : false))
+            (pc->piDiffuseTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piSpecularTexture != NULL ? true : false) !=
+        if  ((pcMesh->piSpecularTexture != nullptr ? true : false) !=
-            (pc->piSpecularTexture != NULL ? true : false))
+            (pc->piSpecularTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piAmbientTexture != NULL ? true : false) !=
+        if  ((pcMesh->piAmbientTexture != nullptr ? true : false) !=
-            (pc->piAmbientTexture != NULL ? true : false))
+            (pc->piAmbientTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piEmissiveTexture != NULL ? true : false) !=
+        if  ((pcMesh->piEmissiveTexture != nullptr ? true : false) !=
-            (pc->piEmissiveTexture != NULL ? true : false))
+            (pc->piEmissiveTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piNormalTexture != NULL ? true : false) !=
+        if  ((pcMesh->piNormalTexture != nullptr ? true : false) !=
-            (pc->piNormalTexture != NULL ? true : false))
+            (pc->piNormalTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piOpacityTexture != NULL ? true : false) !=
+        if  ((pcMesh->piOpacityTexture != nullptr ? true : false) !=
-            (pc->piOpacityTexture != NULL ? true : false))
+            (pc->piOpacityTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piShininessTexture != NULL ? true : false) !=
+        if  ((pcMesh->piShininessTexture != nullptr ? true : false) !=
-            (pc->piShininessTexture != NULL ? true : false))
+            (pc->piShininessTexture != nullptr ? true : false))
             continue;
-        if  ((pcMesh->piLightmapTexture != NULL ? true : false) !=
+        if  ((pcMesh->piLightmapTexture != nullptr ? true : false) !=
-            (pc->piLightmapTexture != NULL ? true : false))
+            (pc->piLightmapTexture != nullptr ? true : false))
             continue;
         if ((pcMesh->eShadingMode != aiShadingMode_Gouraud ? true : false) !=
             (pc->eShadingMode != aiShadingMode_Gouraud ? true : false))
@@ -1239,13 +1238,13 @@ int CMaterialManager::CreateMaterial(
         sMacro[iCurrent].Definition = "1";
         ++iCurrent;
     }
-    sMacro[iCurrent].Name = NULL;
+    sMacro[iCurrent].Name = nullptr;
-    sMacro[iCurrent].Definition = NULL;
+    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 +1332,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 +1475,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
@@ -1490,4 +1489,5 @@ int CMaterialManager::EndMaterial (AssetHelper::MeshHelper* pcMesh)
 
     return 1;
 }
-}; // end namespace AssimpView
+
+} // end namespace AssimpView

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<std::string> 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,"LightColor0",nullptr,nullptr, (BYTE*)&g_avLightColors[0],&dwTemp);
-    RegQueryValueEx(g_hRegistry,"LightColor1",NULL,NULL, (BYTE*)&g_avLightColors[1],&dwTemp);
+    RegQueryValueEx(g_hRegistry,"LightColor1",nullptr,nullptr, (BYTE*)&g_avLightColors[1],&dwTemp);
-    RegQueryValueEx(g_hRegistry,"LightColor2",NULL,NULL, (BYTE*)&g_avLightColors[2],&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,
+        nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        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.lpfnHook = nullptr;
-    clr.lpTemplateName = NULL;
+    clr.lpTemplateName = nullptr;
     clr.lCustData = 0;
 
     ChooseColor(&clr);
@@ -472,8 +472,8 @@ void DisplayColorDialog(D3DXVECTOR4* pclrResult) {
         clamp<unsigned char>(pclrResult->y * 255.0f),
         clamp<unsigned char>(pclrResult->z * 255.0f));
     clr.lpCustColors = g_aclCustomColors;
-    clr.lpfnHook = NULL;
+    clr.lpfnHook = nullptr;
-    clr.lpTemplateName = NULL;
+    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),
+        g_hDlg,GetModuleHandle(nullptr),
-        "Skyboxes\0*.dds\0*.*\0", NULL, 0, 1,
+        "Skyboxes\0*.dds\0*.*\0", nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        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),
+        g_hDlg,GetModuleHandle(nullptr),
-        "PNG Images\0*.png", NULL, 0, 1,
+        "PNG Images\0*.png", nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        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),
+        g_hDlg,GetModuleHandle(nullptr),
-        desc, NULL, 0, 1,
+        desc, nullptr, 0, 1,
-        szFileName, MAX_PATH, NULL, 0, NULL,
+        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) {
+    if (nullptr == hDlg) {
-        MessageBox(NULL,"Failed to create dialog from resource",
+        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);
+        "Software\\ASSIMP\\Viewer",0,nullptr,0,KEY_ALL_ACCESS, nullptr, &hRegistry,nullptr);
-    if(ERROR_SUCCESS == RegQueryValueEx(hRegistry,"LastSkyBoxSrc",NULL,NULL,
+    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 );

tools/assimp_view/assimp_view.cpp

@@ -61,17 +61,17 @@ extern std::string g_szDefaultShader;
 extern std::string g_szPassThroughShader;
 
 //-------------------------------------------------------------------------------
-HINSTANCE g_hInstance				= NULL;
+HINSTANCE g_hInstance				= nullptr;
-HWND g_hDlg							= NULL;
+HWND g_hDlg							= nullptr;
-IDirect3D9* g_piD3D					= NULL;
+IDirect3D9* g_piD3D					= nullptr;
-IDirect3DDevice9* g_piDevice		= NULL;
+IDirect3DDevice9* g_piDevice		= nullptr;
-IDirect3DVertexDeclaration9* gDefaultVertexDecl = NULL;
+IDirect3DVertexDeclaration9* gDefaultVertexDecl = nullptr;
 double g_fFPS						= 0.0f;
 char g_szFileName[MAX_PATH];
-ID3DXEffect* g_piDefaultEffect		= NULL;
+ID3DXEffect* g_piDefaultEffect		= nullptr;
-ID3DXEffect* g_piNormalsEffect		= NULL;
+ID3DXEffect* g_piNormalsEffect		= nullptr;
-ID3DXEffect* g_piPassThroughEffect	= NULL;
+ID3DXEffect* g_piPassThroughEffect	= nullptr;
-ID3DXEffect* g_piPatternEffect		= NULL;
+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(nullptr != piNode);
-    ai_assert(NULL != p_avOut);
+    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(nullptr != pcMesh);
-    ai_assert(NULL != pcSource);
+    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<unsigned char>(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<class TComPtr>
 inline 
-void SafeRelease(TComPtr *ptr) {
+void SafeRelease(TComPtr *&ptr) {
-    if (nullptr != g_piPassThroughEffect) {
+    if (nullptr != ptr) {
-        g_piPassThroughEffect->Release();
+        ptr->Release();
-        g_piPassThroughEffect = nullptr;
+        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);
+    HRSRC res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUD),RT_RCDATA);
-    HGLOBAL hg = LoadResource(NULL,res);
+    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,
+        nullptr,
-        NULL,
+        nullptr,
         &g_pcTexture)))
     {
         CLogDisplay::Instance().AddEntry("[ERROR] Unable to load HUD texture",
             D3DCOLOR_ARGB(0xFF,0xFF,0,0));
 
-        g_pcTexture  = NULL;
+        g_pcTexture  = nullptr;
-        g_szImageMask = NULL;
+        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);
+    res = FindResource(nullptr,MAKEINTRESOURCE(IDR_HUDMASK),RT_RCDATA);
-    hg = LoadResource(NULL,res);
+    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,
+        nullptr,
-        NULL,
+        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,
+        nullptr,
-        NULL,
+        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);