Merge branch 'master' into enable_vs_warning_all

2020-03-15 10:19:49 +01:00 · 2020-03-15 10:19:49 +01:00 · 4210318a34
parent 0357333c81 afccda95f2
commit 4210318a34
48 changed files with 1027 additions and 737 deletions
--- a/.clang-format
+++ b/.clang-format
@ -71,7 +71,7 @@ IncludeCategories:
    Priority:        3
 # IncludeIsMainRegex: '(Test)?$'
 IndentCaseLabels: true
-# IndentPPDirectives: None
+IndentPPDirectives: AfterHash
 IndentWidth:     4
 # IndentWrappedFunctionNames: false
 # JavaScriptQuotes: Leave
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@ -49,7 +49,7 @@ IF(HUNTER_ENABLED)
  )
  add_definitions(-DASSIMP_USE_HUNTER)
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 PROJECT( Assimp VERSION 5.0.1 )
@ -141,9 +141,9 @@ OPTION ( IGNORE_GIT_HASH
 IF (IOS AND NOT HUNTER_ENABLED)
  IF (NOT CMAKE_BUILD_TYPE)
    SET(CMAKE_BUILD_TYPE "Release")
-  ENDIF (NOT CMAKE_BUILD_TYPE)
+  ENDIF ()
  ADD_DEFINITIONS(-DENABLE_BITCODE)
-ENDIF (IOS AND NOT HUNTER_ENABLED)
+ENDIF ()
 # Use subset of Windows.h
 if (WIN32)
@ -159,19 +159,19 @@ IF(MSVC)
    # Multibyte character set is deprecated since at least MSVC2015 (possibly earlier)
    ADD_DEFINITIONS( -DUNICODE -D_UNICODE )
  ENDIF()
-ENDIF(MSVC)
+ENDIF()
 IF (BUILD_FRAMEWORK)
  SET (BUILD_SHARED_LIBS ON)
  MESSAGE(STATUS "Framework bundle building enabled")
-ENDIF(BUILD_FRAMEWORK)
+ENDIF()
 IF(NOT BUILD_SHARED_LIBS)
  MESSAGE(STATUS "Shared libraries disabled")
  SET(LINK_SEARCH_START_STATIC TRUE)
 ELSE()
  MESSAGE(STATUS "Shared libraries enabled")
-ENDIF(NOT BUILD_SHARED_LIBS)
+ENDIF()
 # Define here the needed parameters
 SET (ASSIMP_VERSION_MAJOR ${PROJECT_VERSION_MAJOR})
@ -208,11 +208,11 @@ ENDIF()
 IF(NOT GIT_COMMIT_HASH)
  SET(GIT_COMMIT_HASH 0)
-ENDIF(NOT GIT_COMMIT_HASH)
+ENDIF()
 IF(ASSIMP_DOUBLE_PRECISION)
    ADD_DEFINITIONS(-DASSIMP_DOUBLE_PRECISION)
-ENDIF(ASSIMP_DOUBLE_PRECISION)
+ENDIF()
 CONFIGURE_FILE(
  ${CMAKE_CURRENT_LIST_DIR}/revision.h.in
@ -241,7 +241,7 @@ SET(ASSIMP_LIBRARY_SUFFIX "" CACHE STRING "Suffix to append to library names")
 IF( UNIX )
  # Use GNUInstallDirs for Unix predefined directories
  INCLUDE(GNUInstallDirs)
-ENDIF( UNIX )
+ENDIF()
 # Grouped compiler settings
 IF ((CMAKE_C_COMPILER_ID MATCHES "GNU") AND NOT CMAKE_COMPILER_IS_MINGW)
@ -292,7 +292,7 @@ IF ( IOS AND NOT HUNTER_ENABLED)
    SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fembed-bitcode -O3")
    # Experimental for pdb generation
  ENDIF()
-ENDIF( IOS AND NOT HUNTER_ENABLED)
+ENDIF()
 IF (ASSIMP_COVERALLS)
  MESSAGE(STATUS "Coveralls enabled")
@ -341,10 +341,14 @@ INCLUDE (PrecompiledHeader)
 # source tree. During an out-of-source build, however, do not litter this
 # directory, since that is probably what the user wanted to avoid.
 IF ( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR )
-  SET( CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_HOME_DIRECTORY}/lib" )
+  SET( CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_HOME_DIRECTORY}/bin" )
  SET( CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_HOME_DIRECTORY}/lib" )
  SET( CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_HOME_DIRECTORY}/bin" )
-ENDIF ( CMAKE_SOURCE_DIR STREQUAL CMAKE_BINARY_DIR )
+ELSE()
  SET(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/lib")
  SET(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_BINARY_DIR}/bin")
  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
@ -406,7 +410,7 @@ IF(HUNTER_ENABLED)
      NAMESPACE "${NAMESPACE}"
      DESTINATION "${CONFIG_INSTALL_DIR}"
  )
-ELSE(HUNTER_ENABLED)
+ELSE()
  # cmake configuration files
  if(${BUILD_SHARED_LIBS})
    set(BUILD_LIB_TYPE SHARED)
@ -434,20 +438,16 @@ ELSE(HUNTER_ENABLED)
    "${CMAKE_CURRENT_BINARY_DIR}/assimpTargets.cmake"
    ${PACKAGE_TARGETS_FILE}
    DESTINATION "${ASSIMP_LIB_INSTALL_DIR}/cmake/assimp-${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}" COMPONENT ${LIBASSIMP-DEV_COMPONENT})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 if (ASSIMP_BUILD_SAMPLES OR ASSIMP_BUILD_SAMPLES)
  FIND_PACKAGE(DirectX)
 endif(ASSIMP_BUILD_SAMPLES OR ASSIMP_BUILD_SAMPLES)
 IF( BUILD_DOCS )
  ADD_SUBDIRECTORY(doc)
-ENDIF( BUILD_DOCS )
+ENDIF()
 # Look for system installed irrXML
 IF ( SYSTEM_IRRXML )
  FIND_PACKAGE( IrrXML REQUIRED )
-ENDIF( SYSTEM_IRRXML )
+ENDIF()
 # Search for external dependencies, and build them from source if not found
 # Search for zlib
@ -459,10 +459,10 @@ IF(HUNTER_ENABLED)
  set(ZLIB_FOUND TRUE)
  set(ZLIB_LIBRARIES ZLIB::zlib)
  set(ASSIMP_BUILD_MINIZIP TRUE)
-ELSE(HUNTER_ENABLED)
+ELSE()
  IF ( NOT ASSIMP_BUILD_ZLIB )
    FIND_PACKAGE(ZLIB)
-  ENDIF( NOT ASSIMP_BUILD_ZLIB )
+  ENDIF()
  IF( NOT ZLIB_FOUND )
    MESSAGE(STATUS "compiling zlib from sources")
@ -485,46 +485,46 @@ ELSE(HUNTER_ENABLED)
    SET(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/contrib/zlib ${CMAKE_CURRENT_BINARY_DIR}/contrib/zlib)
    # need to ensure we don't link with system zlib or minizip as well.
    SET(ASSIMP_BUILD_MINIZIP 1)
-  ELSE(NOT ZLIB_FOUND)
+  ELSE()
    ADD_DEFINITIONS(-DASSIMP_BUILD_NO_OWN_ZLIB)
    SET(ZLIB_LIBRARIES_LINKED -lz)
-  ENDIF(NOT ZLIB_FOUND)
+  ENDIF()
  INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 IF( NOT IOS )
  IF( NOT ASSIMP_BUILD_MINIZIP )
    use_pkgconfig(UNZIP minizip)
-  ENDIF( NOT ASSIMP_BUILD_MINIZIP )
+  ENDIF()
-ELSE ( NOT IOS )
+ELSE ()
  IF( NOT BUILD_SHARED_LIBS )
    IF( NOT ASSIMP_BUILD_MINIZIP )
      use_pkgconfig(UNZIP minizip)
-    ENDIF( NOT ASSIMP_BUILD_MINIZIP )
+    ENDIF()
-  ENDIF ( NOT BUILD_SHARED_LIBS )
+  ENDIF ()
-ENDIF ( NOT IOS )
+ENDIF ()
 IF ( ASSIMP_NO_EXPORT )
  ADD_DEFINITIONS( -DASSIMP_BUILD_NO_EXPORT)
  MESSAGE( STATUS "Build an import-only version of Assimp." )
-ENDIF( ASSIMP_NO_EXPORT )
+ENDIF()
 SET ( ASSIMP_BUILD_ARCHITECTURE "" CACHE STRING
  "describe the current architecture."
 )
 IF    ( ASSIMP_BUILD_ARCHITECTURE STREQUAL "")
-ELSE  ( ASSIMP_BUILD_ARCHITECTURE STREQUAL "")
+ELSE  ()
  ADD_DEFINITIONS ( -D'ASSIMP_BUILD_ARCHITECTURE="${ASSIMP_BUILD_ARCHITECTURE}"' )
-ENDIF ( ASSIMP_BUILD_ARCHITECTURE STREQUAL "")
+ENDIF ()
 # ${CMAKE_GENERATOR}
 SET ( ASSIMP_BUILD_COMPILER "" CACHE STRING
  "describe the current compiler."
 )
 IF    ( ASSIMP_BUILD_COMPILER STREQUAL "")
-ELSE  ( ASSIMP_BUILD_COMPILER STREQUAL "")
+ELSE  ()
  ADD_DEFINITIONS ( -D'ASSIMP_BUILD_COMPILER="${ASSIMP_BUILD_COMPILER}"' )
-ENDIF ( ASSIMP_BUILD_COMPILER STREQUAL "")
+ENDIF ()
 MARK_AS_ADVANCED ( ASSIMP_BUILD_ARCHITECTURE ASSIMP_BUILD_COMPILER )
@ -570,45 +570,47 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
    MESSAGE( FATAL_ERROR
      "C4D is currently only available on Windows with melange SDK installed in contrib/Melange"
    )
-  ENDIF ( MSVC )
+  ENDIF ()
-ELSE (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ELSE ()
  ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
-ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ENDIF ()
 IF(NOT HUNTER_ENABLED)
  ADD_SUBDIRECTORY(contrib)
-ENDIF(NOT HUNTER_ENABLED)
+ENDIF()
 ADD_SUBDIRECTORY( code/ )
 IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
  # The viewer for windows only
-  IF ( WIN32 AND DirectX_D3DX9_LIBRARY )
+  IF ( WIN32 )
-    OPTION ( ASSIMP_BUILD_ASSIMP_VIEW "If the Assimp view tool is built. (requires DirectX)" ${DirectX_FOUND} )
+    OPTION ( ASSIMP_BUILD_ASSIMP_VIEW "If the Assimp view tool is built. (requires DirectX)" OFF )
    IF ( ASSIMP_BUILD_ASSIMP_VIEW )
      ADD_SUBDIRECTORY( tools/assimp_view/ )
-    ENDIF ( ASSIMP_BUILD_ASSIMP_VIEW )
+    ENDIF ()
-  ENDIF ( WIN32 AND DirectX_D3DX9_LIBRARY )
+  ENDIF ()
-  # Te command line tool
+  # The command line tool
  ADD_SUBDIRECTORY( tools/assimp_cmd/ )
-ENDIF ( ASSIMP_BUILD_ASSIMP_TOOLS )
+ENDIF ()
 IF ( ASSIMP_BUILD_SAMPLES)
  SET( SAMPLES_DIR ${CMAKE_CURRENT_SOURCE_DIR}/samples )
  SET( SAMPLES_SHARED_CODE_DIR ${SAMPLES_DIR}/SharedCode )
  IF ( WIN32 )
    ADD_SUBDIRECTORY( samples/SimpleTexturedOpenGL/ )
    ADD_SUBDIRECTORY( samples/SimpleTexturedDirectx11 )
-  ENDIF ( WIN32 )
+  ENDIF ()
  ADD_SUBDIRECTORY( samples/SimpleOpenGL/ )
-ENDIF ( ASSIMP_BUILD_SAMPLES )
+ENDIF ()
 IF ( ASSIMP_BUILD_TESTS )
  ADD_SUBDIRECTORY( test/ )
-ENDIF ( ASSIMP_BUILD_TESTS )
+ENDIF ()
 # Generate a pkg-config .pc for the Assimp library.
 CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/assimp.pc.in" "${PROJECT_BINARY_DIR}/assimp.pc" @ONLY )
 IF ( ASSIMP_INSTALL )
  INSTALL( FILES "${PROJECT_BINARY_DIR}/assimp.pc" DESTINATION ${ASSIMP_LIB_INSTALL_DIR}/pkgconfig/ COMPONENT ${LIBASSIMP-DEV_COMPONENT})
-ENDIF( ASSIMP_INSTALL )
+ENDIF()
 IF ( ASSIMP_INSTALL )
  IF(CMAKE_CPACK_COMMAND AND UNIX AND ASSIMP_OPT_BUILD_PACKAGES)
@ -679,7 +681,7 @@ if(WIN32)
      SET(ASSIMP_MSVC_VERSION "vc140")
    ELSEIF(MSVC15)
      SET(ASSIMP_MSVC_VERSION "vc141")
-    ENDIF(MSVC12)
+    ENDIF()
  ENDIF()
  IF(MSVC12 OR MSVC14 OR MSVC15 )
@ -704,5 +706,5 @@ if(WIN32)
      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
      ADD_CUSTOM_COMMAND(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
    ENDIF()
-  ENDIF(MSVC12 OR MSVC14 OR MSVC15 )
+  ENDIF()
-ENDIF (WIN32)
+ENDIF ()
--- a/assimp.pc.in
+++ b/assimp.pc.in
@ -1,7 +1,7 @@
 prefix=@CMAKE_INSTALL_PREFIX@
 exec_prefix=@CMAKE_INSTALL_PREFIX@/
 libdir=@CMAKE_INSTALL_PREFIX@/@ASSIMP_LIB_INSTALL_DIR@
-includedir=@CMAKE_INSTALL_PREFIX@/../include/@ASSIMP_INCLUDE_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.
--- a/assimpTargets-debug.cmake.in
+++ b/assimpTargets-debug.cmake.in
@ -35,7 +35,7 @@ if(MSVC)
  endif()
  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
-  file(TO_NATIVE_PATH ${_IMPORT_PREFIX} _IMPORT_PREFIX)
+  file(TO_NATIVE_PATH "${_IMPORT_PREFIX}" _IMPORT_PREFIX)
  if(ASSIMP_BUILD_SHARED_LIBS)
    set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_DEBUG_POSTFIX@@CMAKE_SHARED_LIBRARY_SUFFIX@")
--- a/assimpTargets-release.cmake.in
+++ b/assimpTargets-release.cmake.in
@ -35,7 +35,7 @@ if(MSVC)
  endif()
  set(ASSIMP_LIBRARY_SUFFIX "@ASSIMP_LIBRARY_SUFFIX@-${MSVC_PREFIX}-mt" CACHE STRING "the suffix for the assimp windows library" )
-  file(TO_NATIVE_PATH ${_IMPORT_PREFIX} _IMPORT_PREFIX)
+  file(TO_NATIVE_PATH "${_IMPORT_PREFIX}" _IMPORT_PREFIX)
  if(ASSIMP_BUILD_SHARED_LIBS)
    set(sharedLibraryName "assimp${ASSIMP_LIBRARY_SUFFIX}@CMAKE_SHARED_LIBRARY_SUFFIX@")
--- a/code/CMakeLists.txt
+++ b/code/CMakeLists.txt
@ -49,7 +49,7 @@ SET( HEADER_PATH ../include/assimp )
 if(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
    message(WARNING "Requesting Android JNI I/O-System in non-Android toolchain. Resetting ASSIMP_ANDROID_JNIIOSYSTEM to OFF.")
    set(ASSIMP_ANDROID_JNIIOSYSTEM OFF)
-endif(NOT ANDROID AND ASSIMP_ANDROID_JNIIOSYSTEM)
+endif()
 SET( COMPILER_HEADERS
  ${HEADER_PATH}/Compiler/pushpack1.h
@ -148,7 +148,7 @@ SET( Core_SRCS
 IF(MSVC)
  list(APPEND Core_SRCS "res/assimp.rc")
-ENDIF(MSVC)
+ENDIF()
 SET( Logging_SRCS
  ${HEADER_PATH}/DefaultLogger.hpp
@ -185,8 +185,6 @@ SET( Common_SRCS
  Common/ScenePreprocessor.cpp
  Common/ScenePreprocessor.h
  Common/SkeletonMeshBuilder.cpp
  Common/SplitByBoneCountProcess.cpp
  Common/SplitByBoneCountProcess.h
  Common/StandardShapes.cpp
  Common/TargetAnimation.cpp
  Common/TargetAnimation.h
@ -222,7 +220,7 @@ IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
    C4D/C4DImporter.h
  )
  SOURCE_GROUP( C4D FILES ${C4D_SRCS})
-ENDIF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
+ENDIF ()
 # if this variable is set to TRUE, the user can manually disable importers by setting
 # ASSIMP_BUILD_XXX_IMPORTER to FALSE for each importer
@ -252,35 +250,39 @@ MACRO(ADD_ASSIMP_IMPORTER name)
  ENDIF()
 ENDMACRO()
-# if this variable is set to TRUE, the user can manually disable exporters by setting
+if (NOT ASSIMP_NO_EXPORT)
 # ASSIMP_BUILD_XXX_EXPORTER to FALSE for each exporter
 # if this variable is set to FALSE, the user can manually enable exporters by setting
 # ASSIMP_BUILD_XXX_EXPORTER to TRUE for each exporter
 OPTION(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_EXPORTER values" TRUE)
-# macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
+  # if this variable is set to TRUE, the user can manually disable exporters by setting
-# this way selective loaders can be compiled (reduces filesize + compile time)
+  # ASSIMP_BUILD_XXX_EXPORTER to FALSE for each exporter
-MACRO(ADD_ASSIMP_EXPORTER name)
+  # if this variable is set to FALSE, the user can manually enable exporters by setting
-  IF (ASSIMP_NO_EXPORT)
+  # ASSIMP_BUILD_XXX_EXPORTER to TRUE for each exporter
-	set(ASSIMP_EXPORTER_ENABLED FALSE)
+  OPTION(ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_EXPORTER values" TRUE)
-  ELSEIF (ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT)
+
-    set(ASSIMP_EXPORTER_ENABLED TRUE)
+  # macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
-    IF (DEFINED ASSIMP_BUILD_${name}_EXPORTER AND NOT ASSIMP_BUILD_${name}_EXPORTER)
+  # this way selective loaders can be compiled (reduces filesize + compile time)
  MACRO(ADD_ASSIMP_EXPORTER name)
    IF (ASSIMP_NO_EXPORT)
      set(ASSIMP_EXPORTER_ENABLED FALSE)
    ELSEIF (ASSIMP_BUILD_ALL_EXPORTERS_BY_DEFAULT)
      set(ASSIMP_EXPORTER_ENABLED TRUE)
      IF (DEFINED ASSIMP_BUILD_${name}_EXPORTER AND NOT ASSIMP_BUILD_${name}_EXPORTER)
        set(ASSIMP_EXPORTER_ENABLED FALSE)
      ENDIF ()
    ELSE ()
      set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER})
    ENDIF ()
  ELSE ()
    set(ASSIMP_EXPORTER_ENABLED ${ASSIMP_BUILD_${name}_EXPORTER})
  ENDIF ()
-  IF (ASSIMP_EXPORTER_ENABLED)
+    IF (ASSIMP_EXPORTER_ENABLED)
-    SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
+      SET(ASSIMP_EXPORTERS_ENABLED "${ASSIMP_EXPORTERS_ENABLED} ${name}")
-	LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
+      LIST(APPEND ASSIMP_EXPORTER_SRCS ${ARGN})
-    SOURCE_GROUP(${name}_EXPORTER FILES ${ARGN})
+      SOURCE_GROUP(${name}_EXPORTER FILES ${ARGN})
-  ELSE()
+    ELSE()
-    SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
+      SET(ASSIMP_EXPORTERS_DISABLED "${ASSIMP_EXPORTERS_DISABLED} ${name}")
-    add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
+      add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
-  ENDIF()
+    ENDIF()
-ENDMACRO()
+  ENDMACRO()
 endif()
 SET(ASSIMP_LOADER_SRCS "")
 SET(ASSIMP_IMPORTERS_ENABLED "") # list of enabled importers
@ -307,11 +309,6 @@ ADD_ASSIMP_IMPORTER( 3DS
  3DS/3DSLoader.h
 )
 ADD_ASSIMP_EXPORTER( 3DS
  3DS/3DSExporter.h
  3DS/3DSExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( AC
  AC/ACLoader.cpp
  AC/ACLoader.h
@ -329,20 +326,6 @@ ADD_ASSIMP_IMPORTER( ASSBIN
  Assbin/AssbinLoader.cpp
 )
 ADD_ASSIMP_EXPORTER( ASSBIN
  Assbin/AssbinExporter.h
  Assbin/AssbinExporter.cpp
  Assbin/AssbinFileWriter.h
  Assbin/AssbinFileWriter.cpp
 )
 ADD_ASSIMP_EXPORTER( ASSXML
  Assxml/AssxmlExporter.h
  Assxml/AssxmlExporter.cpp
  Assxml/AssxmlFileWriter.h
  Assxml/AssxmlFileWriter.cpp
 )
 ADD_ASSIMP_IMPORTER( B3D
  B3D/B3DImporter.cpp
  B3D/B3DImporter.h
@ -362,11 +345,6 @@ ADD_ASSIMP_IMPORTER( COLLADA
  Collada/ColladaParser.h
 )
 ADD_ASSIMP_EXPORTER( COLLADA
  Collada/ColladaExporter.h
  Collada/ColladaExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( DXF
  DXF/DXFLoader.cpp
  DXF/DXFLoader.h
@ -423,11 +401,6 @@ ADD_ASSIMP_IMPORTER( M3D
  M3D/m3d.h
 )
 ADD_ASSIMP_EXPORTER( M3D
  M3D/M3DExporter.h
  M3D/M3DExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( MD2
  MD2/MD2FileData.h
  MD2/MD2Loader.cpp
@ -505,11 +478,6 @@ ADD_ASSIMP_IMPORTER( OBJ
  Obj/ObjTools.h
 )
 ADD_ASSIMP_EXPORTER( OBJ
  Obj/ObjExporter.h
  Obj/ObjExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( OGRE
  Ogre/OgreImporter.h
  Ogre/OgreStructs.h
@ -529,11 +497,6 @@ ADD_ASSIMP_IMPORTER( OPENGEX
  OpenGEX/OpenGEXStructs.h
 )
 ADD_ASSIMP_EXPORTER( OPENGEX
  OpenGEX/OpenGEXExporter.cpp
  OpenGEX/OpenGEXExporter.h
 )
 ADD_ASSIMP_IMPORTER( PLY
  Ply/PlyLoader.cpp
  Ply/PlyLoader.h
@ -541,11 +504,6 @@ ADD_ASSIMP_IMPORTER( PLY
  Ply/PlyParser.h
 )
 ADD_ASSIMP_EXPORTER( PLY
  Ply/PlyExporter.cpp
  Ply/PlyExporter.h
 )
 ADD_ASSIMP_IMPORTER( MS3D
  MS3D/MS3DLoader.cpp
  MS3D/MS3DLoader.h
@ -599,7 +557,7 @@ if (ASSIMP_BUILD_IFC_IMPORTER)
  elseif(CMAKE_COMPILER_IS_MINGW)
    set_source_files_properties(Importer/IFC/IFCReaderGen1_2x3.cpp Importer/IFC/IFCReaderGen2_2x3.cpp PROPERTIES COMPILE_FLAGS "-O2 -Wa,-mbig-obj")
  endif()
-endif (ASSIMP_BUILD_IFC_IMPORTER)
+endif ()
 ADD_ASSIMP_IMPORTER( XGL
  XGL/XGLLoader.cpp
@ -635,14 +593,86 @@ ADD_ASSIMP_IMPORTER( FBX
  FBX/FBXCommon.h
 )
-ADD_ASSIMP_EXPORTER( FBX
+if (NOT ASSIMP_NO_EXPORT)
-  FBX/FBXExporter.h
+
-  FBX/FBXExporter.cpp
+  ADD_ASSIMP_EXPORTER( OBJ
-  FBX/FBXExportNode.h
+    Obj/ObjExporter.h
-  FBX/FBXExportNode.cpp
+    Obj/ObjExporter.cpp)
-  FBX/FBXExportProperty.h
+
-  FBX/FBXExportProperty.cpp
+  ADD_ASSIMP_EXPORTER( OPENGEX
-)
+    OpenGEX/OpenGEXExporter.cpp
    OpenGEX/OpenGEXExporter.h)
  ADD_ASSIMP_EXPORTER( PLY
    Ply/PlyExporter.cpp
    Ply/PlyExporter.h)
  ADD_ASSIMP_EXPORTER( 3DS
    3DS/3DSExporter.h
    3DS/3DSExporter.cpp)
  ADD_ASSIMP_EXPORTER( ASSBIN
    Assbin/AssbinExporter.h
    Assbin/AssbinExporter.cpp
    Assbin/AssbinFileWriter.h
    Assbin/AssbinFileWriter.cpp)
  ADD_ASSIMP_EXPORTER( ASSXML
    Assxml/AssxmlExporter.h
    Assxml/AssxmlExporter.cpp
    Assxml/AssxmlFileWriter.h
    Assxml/AssxmlFileWriter.cpp)
  ADD_ASSIMP_EXPORTER(M3D
    M3D/M3DExporter.h
    M3D/M3DExporter.cpp)
  ADD_ASSIMP_EXPORTER(COLLADA
    Collada/ColladaExporter.h
    Collada/ColladaExporter.cpp)
  ADD_ASSIMP_EXPORTER( FBX
    FBX/FBXExporter.h
    FBX/FBXExporter.cpp
    FBX/FBXExportNode.h
    FBX/FBXExportNode.cpp
    FBX/FBXExportProperty.h
    FBX/FBXExportProperty.cpp)
  ADD_ASSIMP_EXPORTER( STL
    STL/STLExporter.h
    STL/STLExporter.cpp)
  ADD_ASSIMP_EXPORTER( X
    X/XFileExporter.h
    X/XFileExporter.cpp)
  ADD_ASSIMP_EXPORTER( X3D
    X3D/X3DExporter.cpp
    X3D/X3DExporter.hpp)
  ADD_ASSIMP_EXPORTER( GLTF
    glTF/glTFExporter.h
    glTF/glTFExporter.cpp
    glTF2/glTF2Exporter.h
    glTF2/glTF2Exporter.cpp)
  ADD_ASSIMP_EXPORTER( 3MF
    3MF/D3MFExporter.h
    3MF/D3MFExporter.cpp)
  ADD_ASSIMP_EXPORTER( ASSJSON
    Assjson/cencode.c
    Assjson/cencode.h
    Assjson/json_exporter.cpp
    Assjson/mesh_splitter.cpp
    Assjson/mesh_splitter.h)
  ADD_ASSIMP_EXPORTER( STEP
    Step/StepExporter.h
    Step/StepExporter.cpp)
 endif()
 SET( PostProcessing_SRCS
  PostProcessing/CalcTangentsProcess.cpp
@ -705,6 +735,8 @@ SET( PostProcessing_SRCS
  PostProcessing/ArmaturePopulate.h
  PostProcessing/GenBoundingBoxesProcess.cpp
  PostProcessing/GenBoundingBoxesProcess.h
  PostProcessing/SplitByBoneCountProcess.cpp
  PostProcessing/SplitByBoneCountProcess.h
 )
 SOURCE_GROUP( PostProcessing FILES ${PostProcessing_SRCS})
@ -744,11 +776,6 @@ ADD_ASSIMP_IMPORTER( STL
  STL/STLLoader.h
 )
 ADD_ASSIMP_EXPORTER( STL
  STL/STLExporter.h
  STL/STLExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( TERRAGEN
  Terragen/TerragenLoader.cpp
  Terragen/TerragenLoader.h
@ -767,11 +794,6 @@ ADD_ASSIMP_IMPORTER( X
  X/XFileParser.h
 )
 ADD_ASSIMP_EXPORTER( X
  X/XFileExporter.h
  X/XFileExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( X3D
  X3D/X3DImporter.cpp
  X3D/X3DImporter.hpp
@ -792,11 +814,6 @@ ADD_ASSIMP_IMPORTER( X3D
  X3D/X3DVocabulary.cpp
 )
 ADD_ASSIMP_EXPORTER( X3D
  X3D/X3DExporter.cpp
  X3D/X3DExporter.hpp
 )
 ADD_ASSIMP_IMPORTER( GLTF
  glTF/glTFCommon.h
  glTF/glTFCommon.cpp
@ -814,13 +831,6 @@ ADD_ASSIMP_IMPORTER( GLTF
  glTF2/glTF2Importer.h
 )
 ADD_ASSIMP_EXPORTER( GLTF
  glTF/glTFExporter.h
  glTF/glTFExporter.cpp
  glTF2/glTF2Exporter.h
  glTF2/glTF2Exporter.cpp
 )
 ADD_ASSIMP_IMPORTER( 3MF
  3MF/D3MFImporter.h
  3MF/D3MFImporter.cpp
@ -829,11 +839,6 @@ ADD_ASSIMP_IMPORTER( 3MF
  3MF/3MFXmlTags.h
 )
 ADD_ASSIMP_EXPORTER( 3MF
  3MF/D3MFExporter.h
  3MF/D3MFExporter.cpp
 )
 ADD_ASSIMP_IMPORTER( MMD
  MMD/MMDCpp14.h
  MMD/MMDImporter.cpp
@ -844,14 +849,6 @@ ADD_ASSIMP_IMPORTER( MMD
  MMD/MMDVmdParser.h
 )
 ADD_ASSIMP_EXPORTER( ASSJSON
  Assjson/cencode.c
  Assjson/cencode.h
  Assjson/json_exporter.cpp
  Assjson/mesh_splitter.cpp
  Assjson/mesh_splitter.h
 )
 # Workaround for issue #2406 - force problematic large file to be optimized to prevent string table overflow error
 # Used -Os instead of -O2 as previous issues had mentioned, since -Os is roughly speaking -O2, excluding any
 # optimizations that take up extra space. Given that the issue is a string table overflowing, -Os seemed appropriate
@ -874,11 +871,6 @@ endif()
 #    Importer/StepFile/StepReaderGen.h
 #)
 ADD_ASSIMP_EXPORTER( STEP
    Step/StepExporter.h
    Step/StepExporter.cpp
 )
 if ((NOT ASSIMP_NO_EXPORT) OR (NOT ASSIMP_EXPORTERS_ENABLED STREQUAL ""))
 	SET( Exporter_SRCS
 	  Common/Exporter.cpp
@ -897,35 +889,35 @@ SOURCE_GROUP( Extra FILES ${Extra_SRCS})
 IF(HUNTER_ENABLED)
  hunter_add_package(irrXML)
  find_package(irrXML CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  # irrXML already included in contrib directory by parent CMakeLists.txt.
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # utf8
 IF(HUNTER_ENABLED)
  hunter_add_package(utf8)
  find_package(utf8 CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  # utf8 is header-only, so Assimp doesn't need to do anything.
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # polyclipping
 IF(HUNTER_ENABLED)
  hunter_add_package(polyclipping)
  find_package(polyclipping CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  SET( Clipper_SRCS
    ../contrib/clipper/clipper.hpp
    ../contrib/clipper/clipper.cpp
  )
  SOURCE_GROUP( Contrib\\Clipper FILES ${Clipper_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # poly2tri
 IF(HUNTER_ENABLED)
  hunter_add_package(poly2tri)
  find_package(poly2tri CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  SET( Poly2Tri_SRCS
    ../contrib/poly2tri/poly2tri/common/shapes.cc
    ../contrib/poly2tri/poly2tri/common/shapes.h
@ -940,13 +932,13 @@ ELSE(HUNTER_ENABLED)
    ../contrib/poly2tri/poly2tri/sweep/sweep_context.h
  )
  SOURCE_GROUP( Contrib\\Poly2Tri FILES ${Poly2Tri_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # minizip/unzip
 IF(HUNTER_ENABLED)
  hunter_add_package(minizip)
  find_package(minizip CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  SET( unzip_SRCS
    ../contrib/unzip/crypt.h
    ../contrib/unzip/ioapi.c
@ -955,13 +947,13 @@ ELSE(HUNTER_ENABLED)
    ../contrib/unzip/unzip.h
  )
  SOURCE_GROUP(Contrib\\unzip FILES ${unzip_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # zip (https://github.com/kuba--/zip)
 IF(HUNTER_ENABLED)
  hunter_add_package(zip)
  find_package(zip CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  SET( ziplib_SRCS
    ../contrib/zip/src/miniz.h
    ../contrib/zip/src/zip.c
@ -976,13 +968,13 @@ ELSE(HUNTER_ENABLED)
  endif()
  SOURCE_GROUP( ziplib FILES ${ziplib_SRCS} )
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # openddlparser
 IF(HUNTER_ENABLED)
  hunter_add_package(openddlparser)
  find_package(openddlparser CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  SET ( openddl_parser_SRCS
    ../contrib/openddlparser/code/OpenDDLParser.cpp
    ../contrib/openddlparser/code/DDLNode.cpp
@ -999,12 +991,12 @@ ELSE(HUNTER_ENABLED)
    ../contrib/openddlparser/include/openddlparser/Value.h
  )
  SOURCE_GROUP( Contrib\\openddl_parser FILES ${openddl_parser_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # Open3DGC
 IF(HUNTER_ENABLED)
  # Nothing to do, not available in Hunter yet.
-ELSE(HUNTER_ENABLED)
+ELSE()
  SET ( open3dgc_SRCS
    ../contrib/Open3DGC/o3dgcAdjacencyInfo.h
    ../contrib/Open3DGC/o3dgcArithmeticCodec.cpp
@ -1037,7 +1029,7 @@ ELSE(HUNTER_ENABLED)
    ../contrib/Open3DGC/o3dgcVector.inl
  )
  SOURCE_GROUP( Contrib\\open3dgc FILES ${open3dgc_SRCS})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # Check dependencies for glTF importer with Open3DGC-compression.
 # RT-extensions is used in "contrib/Open3DGC/o3dgcTimer.h" for collecting statistics. Pointed file
@ -1056,40 +1048,42 @@ ENDIF ()
 IF(HUNTER_ENABLED)
  hunter_add_package(RapidJSON)
  find_package(RapidJSON CONFIG REQUIRED)
-ELSE(HUNTER_ENABLED)
+ELSE()
  INCLUDE_DIRECTORIES( "../contrib/rapidjson/include" )
  INCLUDE_DIRECTORIES( "../contrib" )
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 # VC2010 fixes
 if(MSVC10)
  option( VC10_STDINT_FIX "Fix for VC10 Compiler regarding pstdint.h redefinition errors" OFF )
  if( VC10_STDINT_FIX )
    ADD_DEFINITIONS( -D_STDINT )
-  endif( VC10_STDINT_FIX )
+  endif()
-endif(MSVC10)
+endif()
 ADD_DEFINITIONS( -DASSIMP_BUILD_DLL_EXPORT )
 if ( MSVC )
  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
-endif ( MSVC )
+endif ()
 IF(NOT HUNTER_ENABLED)
  if (UNZIP_FOUND)
    SET (unzip_compile_SRCS "")
-  else (UNZIP_FOUND)
+  else ()
    SET (unzip_compile_SRCS ${unzip_SRCS})
    INCLUDE_DIRECTORIES( "../contrib/unzip/" )
-  endif (UNZIP_FOUND)
+  endif ()
-ENDIF(NOT HUNTER_ENABLED)
+ENDIF()
 MESSAGE(STATUS "Enabled importer formats:${ASSIMP_IMPORTERS_ENABLED}")
 MESSAGE(STATUS "Disabled importer formats:${ASSIMP_IMPORTERS_DISABLED}")
-MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
+if (NOT ASSIMP_NO_EXPORT)
-MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
+  MESSAGE(STATUS "Enabled exporter formats:${ASSIMP_EXPORTERS_ENABLED}")
  MESSAGE(STATUS "Disabled exporter formats:${ASSIMP_EXPORTERS_DISABLED}")
 endif()
 SOURCE_GROUP( include\\assimp    FILES ${PUBLIC_HEADERS} )
@ -1129,12 +1123,12 @@ IF(NOT HUNTER_ENABLED)
      ${IRRXML_INCLUDE_DIR}
      ../contrib/openddlparser/include
  )
-ENDIF(NOT HUNTER_ENABLED)
+ENDIF()
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
  SET( assimp_src ${assimp_src} ${C4D_SRCS})
  INCLUDE_DIRECTORIES(${C4D_INCLUDES})
-ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ENDIF ()
 ADD_LIBRARY( assimp ${assimp_src} )
 ADD_LIBRARY(assimp::assimp ALIAS assimp)
@ -1158,21 +1152,21 @@ IF(HUNTER_ENABLED)
      utf8::utf8
      zip::zip
  )
-ELSE(HUNTER_ENABLED)
+ELSE()
  TARGET_LINK_LIBRARIES(assimp ${ZLIB_LIBRARIES} ${OPENDDL_PARSER_LIBRARIES} ${IRRXML_LIBRARY} )
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 if(ASSIMP_ANDROID_JNIIOSYSTEM)
  set(ASSIMP_ANDROID_JNIIOSYSTEM_PATH port/AndroidJNI)
  add_subdirectory(../${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/ ../${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/)
  target_link_libraries(assimp android_jniiosystem)
-endif(ASSIMP_ANDROID_JNIIOSYSTEM)
+endif()
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
  TARGET_LINK_LIBRARIES(assimp optimized ${C4D_RELEASE_LIBRARIES})
  TARGET_LINK_LIBRARIES(assimp debug ${C4D_DEBUG_LIBRARIES})
  TARGET_LINK_LIBRARIES(assimp ${C4D_EXTRA_LIBRARIES})
-ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ENDIF ()
 if( MSVC )
  # in order to prevent DLL hell, each of the DLLs have to be suffixed with the major version and msvc prefix
@ -1233,8 +1227,8 @@ if (APPLE)
         "../${HEADER_PATH}/Compiler"
         assimp.framework/Headers/Compiler
      COMMENT "Copying public ./Compiler/ header files to framework bundle's Headers/Compiler/")
-  ENDIF(BUILD_FRAMEWORK)
+  ENDIF()
-ENDIF(APPLE)
+ENDIF()
 # Build against external unzip, or add ../contrib/unzip so
 # assimp can #include "unzip.h"
@ -1242,15 +1236,15 @@ IF(NOT HUNTER_ENABLED)
  if (UNZIP_FOUND)
    INCLUDE_DIRECTORIES(${UNZIP_INCLUDE_DIRS})
    TARGET_LINK_LIBRARIES(assimp ${UNZIP_LIBRARIES})
-  else (UNZIP_FOUND)
+  else ()
    INCLUDE_DIRECTORIES("../")
-  endif (UNZIP_FOUND)
+  endif ()
-ENDIF(NOT HUNTER_ENABLED)
+ENDIF()
 # Add RT-extension library for glTF importer with Open3DGC-compression.
 IF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
  TARGET_LINK_LIBRARIES(assimp ${RT_LIBRARY})
-ENDIF (RT_FOUND AND ASSIMP_IMPORTER_GLTF_USE_OPEN3DGC)
+ENDIF ()
 IF(HUNTER_ENABLED)
  INSTALL( TARGETS assimp
@ -1261,14 +1255,14 @@ IF(HUNTER_ENABLED)
    FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
    COMPONENT ${LIBASSIMP_COMPONENT}
    INCLUDES DESTINATION "include")
-ELSE(HUNTER_ENABLED)
+ELSE()
 INSTALL( TARGETS assimp
    LIBRARY DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
    ARCHIVE DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
    RUNTIME DESTINATION ${ASSIMP_BIN_INSTALL_DIR}
    FRAMEWORK DESTINATION ${ASSIMP_LIB_INSTALL_DIR}
    COMPONENT ${LIBASSIMP_COMPONENT})
-ENDIF(HUNTER_ENABLED)
+ENDIF()
 INSTALL( FILES ${PUBLIC_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp COMPONENT assimp-dev)
 INSTALL( FILES ${COMPILER_HEADERS} DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}/assimp/Compiler COMPONENT assimp-dev)
@ -1276,7 +1270,7 @@ if (ASSIMP_ANDROID_JNIIOSYSTEM)
  INSTALL(FILES ${HEADER_PATH}/${ASSIMP_ANDROID_JNIIOSYSTEM_PATH}/AndroidJNIIOSystem.h
    DESTINATION ${ASSIMP_INCLUDE_INSTALL_DIR}
    COMPONENT assimp-dev)
-ENDIF(ASSIMP_ANDROID_JNIIOSYSTEM)
+ENDIF()
 if(MSVC AND ASSIMP_INSTALL_PDB)
  # When only the static library is built, these properties must
--- a/code/Common/BaseImporter.cpp
+++ b/code/Common/BaseImporter.cpp
@ -191,7 +191,7 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions) {
    }
    std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
-    if (pStream.get() ) {
+    if (pStream) {
        // read 200 characters from the file
        std::unique_ptr<char[]> _buffer (new char[searchBytes+1 /* for the '\0' */]);
        char *buffer( _buffer.get() );
@ -283,7 +283,6 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
        return "";
    }
    // thanks to Andy Maloney for the hint
    std::string ret = file.substr( pos + 1 );
    std::transform( ret.begin(), ret.end(), ret.begin(), ToLower<char>);
@ -309,7 +308,7 @@ std::string BaseImporter::GetExtension( const std::string& file ) {
    };
    magic = reinterpret_cast<const char*>(_magic);
    std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
-    if (pStream.get() ) {
+    if (pStream) {
        // skip to offset
        pStream->Seek(offset,aiOrigin_SET);
@ -603,7 +602,7 @@ unsigned int BatchLoader::AddLoadRequest(const std::string& file,
    }
    // no, we don't have it. So add it to the queue ...
-    m_data->requests.push_back(LoadRequest(file,steps,map, m_data->next_id));
+    m_data->requests.emplace_back(file, steps, map, m_data->next_id);
    return m_data->next_id++;
 }
--- a/code/Common/BaseProcess.cpp
+++ b/code/Common/BaseProcess.cpp
@ -41,45 +41,43 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 /** @file Implementation of BaseProcess */
 #include <assimp/BaseImporter.h>
 #include "BaseProcess.h"
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
 #include "Importer.h"
 #include <assimp/BaseImporter.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 using namespace Assimp;
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 BaseProcess::BaseProcess() AI_NO_EXCEPT
-: shared()
+        : shared(),
-, progress()
+          progress() {
-{
+    // empty
 }
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
-BaseProcess::~BaseProcess()
+BaseProcess::~BaseProcess() {
 {
    // nothing to do here
 }
 // ------------------------------------------------------------------------------------------------
-void BaseProcess::ExecuteOnScene( Importer* pImp)
+void BaseProcess::ExecuteOnScene(Importer *pImp) {
-{
+    ai_assert( nullptr != pImp );
-    ai_assert(NULL != pImp && NULL != pImp->Pimpl()->mScene);
+    ai_assert( nullptr != pImp->Pimpl()->mScene);
    progress = pImp->GetProgressHandler();
-    ai_assert(progress);
+    ai_assert(nullptr != progress);
-    SetupProperties( pImp );
+    SetupProperties(pImp);
    // catch exceptions thrown inside the PostProcess-Step
-    try
+    try {
    {
        Execute(pImp->Pimpl()->mScene);
-    } catch( const std::exception& err )    {
+    } catch (const std::exception &err) {
        // extract error description
        pImp->Pimpl()->mErrorString = err.what();
@ -92,14 +90,11 @@ void BaseProcess::ExecuteOnScene( Importer* pImp)
 }
 // ------------------------------------------------------------------------------------------------
-void BaseProcess::SetupProperties(const Importer* /*pImp*/)
+void BaseProcess::SetupProperties(const Importer * /*pImp*/) {
 {
    // the default implementation does nothing
 }
 // ------------------------------------------------------------------------------------------------
-bool BaseProcess::RequireVerboseFormat() const
+bool BaseProcess::RequireVerboseFormat() const {
 {
    return true;
 }
--- a/code/Common/BaseProcess.h
+++ b/code/Common/BaseProcess.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,
@ -44,12 +43,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_BASEPROCESS_H
 #define INCLUDED_AI_BASEPROCESS_H
 #include <map>
 #include <assimp/GenericProperty.h>
 #include <map>
 struct aiScene;
-namespace Assimp    {
+namespace Assimp {
 class Importer;
@ -60,64 +60,50 @@ class Importer;
 *  to provide additional information to other steps. This is primarily
 *  intended for cross-step optimizations.
 */
-class SharedPostProcessInfo
+class SharedPostProcessInfo {
 {
 public:
-
+    struct Base {
-    struct Base
+        virtual ~Base() {}
    {
        virtual ~Base()
        {}
    };
    //! Represents data that is allocated on the heap, thus needs to be deleted
    template <typename T>
-    struct THeapData : public Base
+    struct THeapData : public Base {
-    {
+        explicit THeapData(T *in) :
-        explicit THeapData(T* in)
+                data(in) {}
            : data (in)
        {}
-        ~THeapData()
+        ~THeapData() {
        {
            delete data;
        }
-        T* data;
+        T *data;
    };
    //! Represents static, by-value data not allocated on the heap
    template <typename T>
-    struct TStaticData : public Base
+    struct TStaticData : public Base {
-    {
+        explicit TStaticData(T in) :
-        explicit TStaticData(T in)
+                data(in) {}
            : data (in)
        {}
-        ~TStaticData()
+        ~TStaticData() {}
        {}
        T data;
    };
    // some typedefs for cleaner code
    typedef unsigned int KeyType;
-    typedef std::map<KeyType, Base*>  PropertyMap;
+    typedef std::map<KeyType, Base *> PropertyMap;
 public:
    //! Destructor
-    ~SharedPostProcessInfo()
+    ~SharedPostProcessInfo() {
    {
        Clean();
    }
    //! Remove all stored properties from the table
-    void Clean()
+    void Clean() {
    {
        // invoke the virtual destructor for all stored properties
        for (PropertyMap::iterator it = pmap.begin(), end = pmap.end();
-             it != end; ++it)
+                it != end; ++it) {
        {
            delete (*it).second;
        }
        pmap.clear();
@ -125,24 +111,21 @@ public:
    //! Add a heap property to the list
    template <typename T>
-    void AddProperty( const char* name, T* in ){
+    void AddProperty(const char *name, T *in) {
-        AddProperty(name,(Base*)new THeapData<T>(in));
+        AddProperty(name, (Base *)new THeapData<T>(in));
    }
    //! Add a static by-value property to the list
    template <typename T>
-    void AddProperty( const char* name, T in ){
+    void AddProperty(const char *name, T in) {
-        AddProperty(name,(Base*)new TStaticData<T>(in));
+        AddProperty(name, (Base *)new TStaticData<T>(in));
    }
    //! Get a heap property
    template <typename T>
-    bool GetProperty( const char* name, T*& out ) const
+    bool GetProperty(const char *name, T *&out) const {
-    {
+        THeapData<T> *t = (THeapData<T> *)GetPropertyInternal(name);
-        THeapData<T>* t = (THeapData<T>*)GetPropertyInternal(name);
+        if (!t) {
        if(!t)
        {
            out = NULL;
            return false;
        }
@ -152,53 +135,34 @@ public:
    //! Get a static, by-value property
    template <typename T>
-    bool GetProperty( const char* name, T& out ) const
+    bool GetProperty(const char *name, T &out) const {
-    {
+        TStaticData<T> *t = (TStaticData<T> *)GetPropertyInternal(name);
-        TStaticData<T>* t = (TStaticData<T>*)GetPropertyInternal(name);
+        if ( nullptr == t) {
-        if(!t)return false;
+            return false;
        }
        out = t->data;
        return true;
    }
    //! Remove a property of a specific type
-    void RemoveProperty( const char* name)  {
+    void RemoveProperty(const char *name) {
-        SetGenericPropertyPtr<Base>(pmap,name,NULL);
+        SetGenericPropertyPtr<Base>(pmap, name, nullptr );
    }
 private:
-
+    void AddProperty(const char *name, Base *data) {
-    void AddProperty( const char* name, Base* data) {
+        SetGenericPropertyPtr<Base>(pmap, name, data);
        SetGenericPropertyPtr<Base>(pmap,name,data);
    }
-    Base* GetPropertyInternal( const char* name) const  {
+    Base *GetPropertyInternal(const char *name) const {
-        return GetGenericProperty<Base*>(pmap,name,NULL);
+        return GetGenericProperty<Base *>(pmap, name, nullptr );
    }
 private:
    //! Map of all stored properties
    PropertyMap pmap;
 };
 #if 0
 // ---------------------------------------------------------------------------
 /** @brief Represents a dependency table for a postprocessing steps.
 *
 *  For future use.
 */
 struct PPDependencyTable
 {
     unsigned int execute_me_before_these;
     unsigned int execute_me_after_these;
     unsigned int only_if_these_are_not_specified;
     unsigned int mutually_exclusive_with;
 };
 #endif
 #define AI_SPP_SPATIAL_SORT "$Spat"
 // ---------------------------------------------------------------------------
@ -228,7 +192,7 @@ public:
     * @return true if the process is present in this flag fields,
     *   false if not.
    */
-    virtual bool IsActive( unsigned int pFlags) const = 0;
+    virtual bool IsActive(unsigned int pFlags) const = 0;
    // -------------------------------------------------------------------
    /** Check whether this step expects its input vertex data to be
@ -241,14 +205,14 @@ public:
    * the object pointer will be set to NULL).
    * @param pImp Importer instance (pImp->mScene must be valid)
    */
-    void ExecuteOnScene( Importer* pImp);
+    void ExecuteOnScene(Importer *pImp);
    // -------------------------------------------------------------------
    /** Called prior to ExecuteOnScene().
    * The function is a request to the process to update its configuration
    * basing on the Importer's configuration property list.
    */
-    virtual void SetupProperties(const Importer* pImp);
+    virtual void SetupProperties(const Importer *pImp);
    // -------------------------------------------------------------------
    /** Executes the post processing step on the given imported data.
@ -256,35 +220,32 @@ public:
    * This method must be implemented by deriving classes.
    * @param pScene The imported data to work at.
    */
-    virtual void Execute( aiScene* pScene) = 0;
+    virtual void Execute(aiScene *pScene) = 0;
    // -------------------------------------------------------------------
    /** Assign a new SharedPostProcessInfo to the step. This object
     *  allows multiple postprocess steps to share data.
     * @param sh May be NULL
    */
-    inline void SetSharedData(SharedPostProcessInfo* sh)    {
+    inline void SetSharedData(SharedPostProcessInfo *sh) {
        shared = sh;
    }
    // -------------------------------------------------------------------
    /** Get the shared data that is assigned to the step.
    */
-    inline SharedPostProcessInfo* GetSharedData()   {
+    inline SharedPostProcessInfo *GetSharedData() {
        return shared;
    }
 protected:
    /** See the doc of #SharedPostProcessInfo for more details */
-    SharedPostProcessInfo* shared;
+    SharedPostProcessInfo *shared;
    /** Currently active progress handler */
-    ProgressHandler* progress;
+    ProgressHandler *progress;
 };
 } // end of namespace Assimp
 #endif // AI_BASEPROCESS_H_INC
--- a/code/Common/Importer.cpp
+++ b/code/Common/Importer.cpp
@ -1071,7 +1071,7 @@ ai_real Importer::GetPropertyFloat(const char* szName, ai_real iErrorReturn /*=
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-const std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
+std::string Importer::GetPropertyString(const char* szName, const std::string& iErrorReturn /*= ""*/) const {
    ai_assert(nullptr != pimpl);
    return GetGenericProperty<std::string>(pimpl->mStringProperties,szName,iErrorReturn);
@ -1079,7 +1079,7 @@ const std::string Importer::GetPropertyString(const char* szName, const std::str
 // ------------------------------------------------------------------------------------------------
 // Get a configuration property
-const aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
+aiMatrix4x4 Importer::GetPropertyMatrix(const char* szName, const aiMatrix4x4& iErrorReturn /*= aiMatrix4x4()*/) const {
    ai_assert(nullptr != pimpl);
    return GetGenericProperty<aiMatrix4x4>(pimpl->mMatrixProperties,szName,iErrorReturn);
@ -1110,10 +1110,9 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
    aiScene* mScene = pimpl->mScene;
    // return if we have no scene loaded
-    if (!pimpl->mScene)
+    if (!mScene)
        return;
    in.total = sizeof(aiScene);
    // add all meshes
@ -1202,5 +1201,6 @@ void Importer::GetMemoryRequirements(aiMemoryInfo& in) const {
            in.materials += pc->mProperties[a]->mDataLength;
        }
    }
    in.total += in.materials;
 }
--- a/code/Common/PostStepRegistry.cpp
+++ b/code/Common/PostStepRegistry.cpp
@ -123,7 +123,7 @@ corresponding preprocessor flag to selectively disable steps.
 #   include "PostProcessing/OptimizeGraph.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_SPLITBYBONECOUNT_PROCESS
-#   include "Common/SplitByBoneCountProcess.h"
+#   include "PostProcessing/SplitByBoneCountProcess.h"
 #endif
 #ifndef ASSIMP_BUILD_NO_DEBONE_PROCESS
 #   include "PostProcessing/DeboneProcess.h"
--- a/code/Common/ZipArchiveIOSystem.cpp
+++ b/code/Common/ZipArchiveIOSystem.cpp
@ -343,8 +343,6 @@ namespace Assimp {
    }
    ZipArchiveIOSystem::Implement::~Implement() {
        m_ArchiveMap.clear();
        if (m_ZipFileHandle != nullptr) {
            unzClose(m_ZipFileHandle);
            m_ZipFileHandle = nullptr;
--- a/code/Obj/ObjFileData.h
+++ b/code/Obj/ObjFileData.h
@ -110,10 +110,7 @@ struct Object {
    std::vector<unsigned int> m_Meshes;
    //! \brief  Default constructor
-    Object() 
+    Object() = default;
    : m_strObjName("") {
        // empty
    }
    //! \brief  Destructor
    ~Object() {
@ -191,16 +188,12 @@ struct Material {
    ,   illumination_model (1)
    ,   ior     ( ai_real( 1.0 ) )
    ,   transparent( ai_real( 1.0), ai_real (1.0), ai_real(1.0)) {
-        // empty
+
-        for (size_t i = 0; i < TextureTypeCount; ++i) {
+	    std::fill_n(clamp, static_cast<unsigned int>(TextureTypeCount), false);
            clamp[ i ] = false;
        }
    }
    // Destructor
-    ~Material() {
+    ~Material() = default;
        // empty
    }
 };
 // ------------------------------------------------------------------------------------------------
--- a/code/Obj/ObjFileParser.cpp
+++ b/code/Obj/ObjFileParser.cpp
@ -53,6 +53,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/material.h>
 #include <assimp/Importer.hpp>
 #include <cstdlib>
 #include <memory>
 #include <utility>
 namespace Assimp {
@ -71,16 +73,16 @@ ObjFileParser::ObjFileParser()
 ObjFileParser::ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName,
                              IOSystem *io, ProgressHandler* progress,
-                              const std::string &originalObjFileName) :
+                              std::string originalObjFileName) :
    m_DataIt(),
    m_DataItEnd(),
    m_pModel(nullptr),
    m_uiLine(0),
-    m_pIO( io ),
+    m_pIO(io),
    m_progress(progress),
-    m_originalObjFileName(originalObjFileName)
+    m_originalObjFileName(std::move(originalObjFileName))
 {
-    std::fill_n(m_buffer,Buffersize,'\0');
+    std::fill_n(m_buffer, Buffersize,0);
    // Create the model instance to store all the data
    m_pModel.reset(new ObjFile::Model());
@ -96,7 +98,8 @@ ObjFileParser::ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::str
    parseFile( streamBuffer );
 }
-ObjFileParser::~ObjFileParser() {
+ObjFileParser::~ObjFileParser()
 {
 }
 void ObjFileParser::setBuffer( std::vector<char> &buffer ) {
@ -128,7 +131,7 @@ void ObjFileParser::parseFile( IOStreamBuffer<char> &streamBuffer ) {
            processed = static_cast<unsigned int>(filePos);
            lastFilePos = filePos;
            progressCounter++;
-            m_progress->UpdateFileRead( processed, progressTotal );
+            m_progress->UpdateFileRead(processed, progressTotal);
        }
        // parse line
--- a/code/Obj/ObjFileParser.h
+++ b/code/Obj/ObjFileParser.h
@ -78,7 +78,7 @@ public:
    /// @brief  The default constructor.
    ObjFileParser();
    /// @brief  Constructor with data array.
-    ObjFileParser( IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem* io, ProgressHandler* progress, const std::string &originalObjFileName);
+    ObjFileParser(IOStreamBuffer<char> &streamBuffer, const std::string &modelName, IOSystem* io, ProgressHandler* progress, std::string originalObjFileName);
    /// @brief  Destructor
    ~ObjFileParser();
    /// @brief  If you want to load in-core data.
--- a/code/PostProcessing/SplitByBoneCountProcess.cpp
+++ b/code/PostProcessing/SplitByBoneCountProcess.cpp
@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <limits>
 #include <assimp/TinyFormatter.h>
 #include <assimp/Exceptional.h>
 using namespace Assimp;
 using namespace Assimp::Formatter;
@ -94,7 +95,10 @@ void SplitByBoneCountProcess::Execute( aiScene* pScene)
    bool isNecessary = false;
    for( unsigned int a = 0; a < pScene->mNumMeshes; ++a)
        if( pScene->mMeshes[a]->mNumBones > mMaxBoneCount )
        {
            isNecessary = true;
            break;
        }
    if( !isNecessary )
    {
@ -155,7 +159,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
 {
    // skip if not necessary
    if( pMesh->mNumBones <= mMaxBoneCount )
    {
        return;
    }
    // necessary optimisation: build a list of all affecting bones for each vertex
    // TODO: (thom) maybe add a custom allocator here to avoid allocating tens of thousands of small arrays
@ -165,7 +171,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
    {
        const aiBone* bone = pMesh->mBones[a];
        for( unsigned int b = 0; b < bone->mNumWeights; ++b)
        {
            vertexBones[ bone->mWeights[b].mVertexId ].push_back( BoneWeight( a, bone->mWeights[b].mWeight));
        }
    }
    unsigned int numFacesHandled = 0;
@ -189,7 +197,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
        {
            // skip if the face is already stored in a submesh
            if( isFaceHandled[a] )
            {
                continue;
            }
            const aiFace& face = pMesh->mFaces[a];
            // check every vertex if its bones would still fit into the current submesh
@ -201,17 +211,27 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
                    unsigned int boneIndex = vb[c].first;
                    // if the bone is already used in this submesh, it's ok
                    if( isBoneUsed[boneIndex] )
                    {
                        continue;
                    }
                    // if it's not used, yet, we would need to add it. Store its bone index
                    if( std::find( newBonesAtCurrentFace.begin(), newBonesAtCurrentFace.end(), boneIndex) == newBonesAtCurrentFace.end() )
                    {
                        newBonesAtCurrentFace.push_back( boneIndex);
                    }
                }
            }
            if (newBonesAtCurrentFace.size() > mMaxBoneCount)
            {
                throw DeadlyImportError("SplitByBoneCountProcess: Single face requires more bones than specified max bone count!");
            }
            // leave out the face if the new bones required for this face don't fit the bone count limit anymore
            if( numBones + newBonesAtCurrentFace.size() > mMaxBoneCount )
            {
                continue;
            }
            // mark all new bones as necessary
            while( !newBonesAtCurrentFace.empty() )
@ -219,7 +239,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
                unsigned int newIndex = newBonesAtCurrentFace.back();
                newBonesAtCurrentFace.pop_back(); // this also avoids the deallocation which comes with a clear()
                if( isBoneUsed[newIndex] )
                {
                    continue;
                }
                isBoneUsed[newIndex] = true;
                numBones++;
@ -237,7 +259,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
        // create a new mesh to hold this subset of the source mesh
        aiMesh* newMesh = new aiMesh;
        if( pMesh->mName.length > 0 )
        {
            newMesh->mName.Set( format() << pMesh->mName.data << "_sub" << poNewMeshes.size());
        }
        newMesh->mMaterialIndex = pMesh->mMaterialIndex;
        newMesh->mPrimitiveTypes = pMesh->mPrimitiveTypes;
        poNewMeshes.push_back( newMesh);
@ -247,7 +271,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
        newMesh->mNumFaces = static_cast<unsigned int>(subMeshFaces.size());
        newMesh->mVertices = new aiVector3D[newMesh->mNumVertices];
        if( pMesh->HasNormals() )
        {
            newMesh->mNormals = new aiVector3D[newMesh->mNumVertices];
        }
        if( pMesh->HasTangentsAndBitangents() )
        {
            newMesh->mTangents = new aiVector3D[newMesh->mNumVertices];
@ -256,13 +282,17 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
        {
            if( pMesh->HasTextureCoords( a) )
            {
                newMesh->mTextureCoords[a] = new aiVector3D[newMesh->mNumVertices];
            }
            newMesh->mNumUVComponents[a] = pMesh->mNumUVComponents[a];
        }
        for( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
        {
            if( pMesh->HasVertexColors( a) )
            {
                newMesh->mColors[a] = new aiColor4D[newMesh->mNumVertices];
            }
        }
        // and copy over the data, generating faces with linear indices along the way
@ -285,7 +315,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
                newMesh->mVertices[nvi] = pMesh->mVertices[srcIndex];
                if( pMesh->HasNormals() )
                {
                    newMesh->mNormals[nvi] = pMesh->mNormals[srcIndex];
                }
                if( pMesh->HasTangentsAndBitangents() )
                {
                    newMesh->mTangents[nvi] = pMesh->mTangents[srcIndex];
@ -294,12 +326,16 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
                for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++c )
                {
                    if( pMesh->HasTextureCoords( c) )
                    {
                        newMesh->mTextureCoords[c][nvi] = pMesh->mTextureCoords[c][srcIndex];
                    }
                }
                for( unsigned int c = 0; c < AI_MAX_NUMBER_OF_COLOR_SETS; ++c )
                {
                    if( pMesh->HasVertexColors( c) )
                    {
                        newMesh->mColors[c][nvi] = pMesh->mColors[c][srcIndex];
                    }
                }
                nvi++;
@ -316,7 +352,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
        for( unsigned int a = 0; a < pMesh->mNumBones; ++a )
        {
            if( !isBoneUsed[a] )
            {
                continue;
            }
            // create the new bone
            const aiBone* srcBone = pMesh->mBones[a];
@ -340,7 +378,9 @@ void SplitByBoneCountProcess::SplitMesh( const aiMesh* pMesh, std::vector<aiMesh
            {
                unsigned int newBoneIndex = mappedBoneIndex[ bonesOnThisVertex[b].first ];
                if( newBoneIndex != std::numeric_limits<unsigned int>::max() )
                {
                    newMesh->mBones[newBoneIndex]->mNumWeights++;
                }
            }
        }
--- a/code/PostProcessing/SplitByBoneCountProcess.h
+++ b/code/PostProcessing/SplitByBoneCountProcess.h
@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_SPLITBYBONECOUNTPROCESS_H_INC
 #include <vector>
-#include "BaseProcess.h"
+#include "Common/BaseProcess.h"
 #include <assimp/mesh.h>
 #include <assimp/scene.h>
--- a/code/PostProcessing/TextureTransform.cpp
+++ b/code/PostProcessing/TextureTransform.cpp
@ -92,9 +92,8 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
     *  are applied is - as always - scaling, rotation, translation.
     */
-    char szTemp[512];
+	int rounded;
-    int rounded = 0;
+	char szTemp[512];
    /* Optimize the rotation angle. That's slightly difficult as
     * we have an inprecise floating-point number (when comparing
@ -188,7 +187,6 @@ void TextureTransformStep::PreProcessUVTransform(STransformVecInfo& info)
            info.mTranslation.y = out;
        }
    }
    return;
 }
 // ------------------------------------------------------------------------------------------------
@ -431,7 +429,7 @@ void TextureTransformStep::Execute( aiScene* pScene)
        // at the end of the list
        bool ref[AI_MAX_NUMBER_OF_TEXTURECOORDS];
        for (unsigned int n = 0; n < AI_MAX_NUMBER_OF_TEXTURECOORDS;++n)
-            ref[n] = (!mesh->mTextureCoords[n] ? true : false);
+            ref[n] = !mesh->mTextureCoords[n];
        for (it = trafo.begin();it != trafo.end(); ++it)
            ref[(*it).uvIndex] = true;
--- a/code/glTF/glTFImporter.cpp
+++ b/code/glTF/glTFImporter.cpp
@ -221,6 +221,7 @@ void glTFImporter::ImportMeshes(glTF::Asset& r)
    std::vector<aiMesh*> meshes;
    unsigned int k = 0;
    meshOffsets.clear();
    for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
        Mesh& mesh = r.meshes[m];
--- a/code/glTF2/glTF2Importer.cpp
+++ b/code/glTF2/glTF2Importer.cpp
@ -112,7 +112,7 @@ bool glTF2Importer::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool
 	if (extension != "gltf" && extension != "glb") {
        return false;
-    }
+  }
 	if (pIOHandler) {
 		glTF2::Asset asset(pIOHandler);
@ -323,8 +323,9 @@ static inline bool CheckValidFacesIndices(aiFace *faces, unsigned nFaces, unsign
 	for (unsigned i = 0; i < nFaces; ++i) {
 		for (unsigned j = 0; j < faces[i].mNumIndices; ++j) {
 			unsigned idx = faces[i].mIndices[j];
-			if (idx >= nVerts)
+			if (idx >= nVerts) {
 				return false;
 			}
 		}
 	}
 	return true;
@ -335,6 +336,7 @@ void glTF2Importer::ImportMeshes(glTF2::Asset &r) {
 	std::vector<aiMesh *> meshes;
 	unsigned int k = 0;
    meshOffsets.clear();
 	for (unsigned int m = 0; m < r.meshes.Size(); ++m) {
 		Mesh &mesh = r.meshes[m];
@ -860,7 +862,19 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
 		if (node.skin) {
 			for (int primitiveNo = 0; primitiveNo < count; ++primitiveNo) {
 				aiMesh *mesh = pScene->mMeshes[meshOffsets[mesh_idx] + primitiveNo];
-				mesh->mNumBones = static_cast<unsigned int>(node.skin->jointNames.size());
+				unsigned int numBones =static_cast<unsigned int>(node.skin->jointNames.size());
 				std::vector<std::vector<aiVertexWeight>> weighting(numBones);
 				BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
 				unsigned int realNumBones = 0;
 				for (uint32_t i = 0; i < numBones; ++i) {
 					if (weighting[i].size() > 0) {
 						realNumBones++;
 					}
 				}
 				mesh->mNumBones = static_cast<unsigned int>(realNumBones);
 				mesh->mBones = new aiBone *[mesh->mNumBones];
 				// GLTF and Assimp choose to store bone weights differently.
@ -872,43 +886,33 @@ aiNode *ImportNode(aiScene *pScene, glTF2::Asset &r, std::vector<unsigned int> &
 				// both because it's somewhat slow and because, for many applications,
 				// we then need to reconvert the data back into the vertex-to-bone
 				// mapping which makes things doubly-slow.
 				std::vector<std::vector<aiVertexWeight>> weighting(mesh->mNumBones);
 				BuildVertexWeightMapping(node.meshes[0]->primitives[primitiveNo], weighting);
 				mat4 *pbindMatrices = nullptr;
 				node.skin->inverseBindMatrices->ExtractData(pbindMatrices);
-				for (uint32_t i = 0; i < mesh->mNumBones; ++i) {
+				int cb = 0;
-					aiBone *bone = new aiBone();
+				for (uint32_t i = 0; i < numBones; ++i) {
 					const std::vector<aiVertexWeight> &weights = weighting[i];
 					if (weights.size() > 0) {
 						aiBone *bone = new aiBone();
-					Ref<Node> joint = node.skin->jointNames[i];
+						Ref<Node> joint = node.skin->jointNames[i];
-					if (!joint->name.empty()) {
+						if (!joint->name.empty()) {
-						bone->mName = joint->name;
+							bone->mName = joint->name;
-					} else {
+						} else {
-						// Assimp expects each bone to have a unique name.
+							// Assimp expects each bone to have a unique name.
-						static const std::string kDefaultName = "bone_";
+							static const std::string kDefaultName = "bone_";
-						char postfix[10] = { 0 };
+							char postfix[10] = { 0 };
-						ASSIMP_itoa10(postfix, i);
+							ASSIMP_itoa10(postfix, i);
-						bone->mName = (kDefaultName + postfix);
+							bone->mName = (kDefaultName + postfix);
-					}
+						}
-					GetNodeTransform(bone->mOffsetMatrix, *joint);
+						GetNodeTransform(bone->mOffsetMatrix, *joint);
-
+						CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
-					CopyValue(pbindMatrices[i], bone->mOffsetMatrix);
+						bone->mNumWeights = static_cast<uint32_t>(weights.size());
 					std::vector<aiVertexWeight> &weights = weighting[i];
 					bone->mNumWeights = static_cast<uint32_t>(weights.size());
 					if (bone->mNumWeights > 0) {
 						bone->mWeights = new aiVertexWeight[bone->mNumWeights];
 						memcpy(bone->mWeights, weights.data(), bone->mNumWeights * sizeof(aiVertexWeight));
-					} else {
+						mesh->mBones[cb++] = bone;
 						// Assimp expects all bones to have at least 1 weight.
 						bone->mWeights = new aiVertexWeight[1];
 						bone->mNumWeights = 1;
 						bone->mWeights->mVertexId = 0;
 						bone->mWeights->mWeight = 0.f;
 					}
 					mesh->mBones[i] = bone;
 				}
 				if (pbindMatrices) {
@ -1231,8 +1235,9 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
 	int numEmbeddedTexs = 0;
 	for (size_t i = 0; i < r.images.Size(); ++i) {
-		if (r.images[i].HasData())
+		if (r.images[i].HasData()) {
 			numEmbeddedTexs += 1;
 		}
 	}
 	if (numEmbeddedTexs == 0)
@ -1243,7 +1248,9 @@ void glTF2Importer::ImportEmbeddedTextures(glTF2::Asset &r) {
 	// Add the embedded textures
 	for (size_t i = 0; i < r.images.Size(); ++i) {
 		Image &img = r.images[i];
-		if (!img.HasData()) continue;
+		if (!img.HasData()) {
 			continue;
 		}
 		int idx = mScene->mNumTextures++;
 		embeddedTexIdxs[i] = idx;
--- a/contrib/CMakeLists.txt
+++ b/contrib/CMakeLists.txt
@ -1,4 +1,4 @@
 # Compile internal irrXML only if system is not requested
 if( NOT SYSTEM_IRRXML )
    add_subdirectory(irrXML)
-endif( NOT SYSTEM_IRRXML )
+endif()
--- a/contrib/zip/CMakeLists.txt
+++ b/contrib/zip/CMakeLists.txt
@ -2,7 +2,7 @@ cmake_minimum_required(VERSION 3.0)
 project(zip
  LANGUAGES C
-  VERSION "0.1.15")
+  VERSION "0.1.18")
 set(CMAKE_MODULE_PATH "${PROJECT_SOURCE_DIR}/cmake" ${CMAKE_MODULE_PATH})
 option(CMAKE_DISABLE_TESTING "Disable test creation" OFF)
@ -16,10 +16,6 @@ elseif ("${CMAKE_C_COMPILER_ID}" STREQUAL "GNU" OR
        "${CMAKE_C_COMPILER_ID}" STREQUAL "Clang" OR
        "${CMAKE_C_COMPILER_ID}" STREQUAL "AppleClang")
  set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -std=c99 -Wall -Wextra -Werror -pedantic")
  if(ENABLE_COVERAGE)
    set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
    set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage")
  endif()
 endif (MSVC)
 # zip
@ -35,7 +31,7 @@ if (NOT CMAKE_DISABLE_TESTING)
  enable_testing()
  add_subdirectory(test)
  find_package(Sanitizers)
-  add_sanitizers(${PROJECT_NAME} ${test_out} ${test_miniz_out})
+  add_sanitizers(${PROJECT_NAME} ${test_out})
 endif()
 ####
--- a/contrib/zip/README.md
+++ b/contrib/zip/README.md
@ -1,10 +1,8 @@
 ### A portable (OSX/Linux/Windows), simple zip library written in C
 This is done by hacking awesome [miniz](https://code.google.com/p/miniz) library and layering functions on top of the miniz v1.15 API.
-[![Windows](https://ci.appveyor.com/api/projects/status/bph8dr3jacgmjv32/branch/master?svg=true&label=windows)](https://ci.appveyor.com/project/kuba--/zip)
+[![Build](https://github.com/kuba--/zip/workflows/build/badge.svg)](https://github.com/kuba--/zip/actions?query=workflow%3Abuild)
 [![Linux](https://travis-ci.org/kuba--/zip.svg?branch=master&label=linux%2fosx)](https://travis-ci.org/kuba--/zip)
 [![Version](https://badge.fury.io/gh/kuba--%2Fzip.svg)](https://github.com/kuba--/zip/releases)
 [![Codecov](https://codecov.io/gh/kuba--/zip/branch/master/graph/badge.svg)](https://codecov.io/gh/kuba--/zip)
 # The Idea
@ -213,6 +211,53 @@ func main() {
 }
 ```
 ### Rust (ffi)
 ```rust
 extern crate libc;
 use std::ffi::CString;
 #[repr(C)]
 pub struct Zip {
    _private: [u8; 0],
 }
 #[link(name = "zip")]
 extern "C" {
    fn zip_open(path: *const libc::c_char, level: libc::c_int, mode: libc::c_char) -> *mut Zip;
    fn zip_close(zip: *mut Zip) -> libc::c_void;
    fn zip_entry_open(zip: *mut Zip, entryname: *const libc::c_char) -> libc::c_int;
    fn zip_entry_close(zip: *mut Zip) -> libc::c_int;
    fn zip_entry_write(
        zip: *mut Zip,
        buf: *const libc::c_void,
        bufsize: libc::size_t,
    ) -> libc::c_int;
 }
 fn main() {
    let path = CString::new("/tmp/test.zip").unwrap();
    let mode: libc::c_char = 'w' as libc::c_char;
    let entryname = CString::new("test.txt").unwrap();
    let content = "test content\0";
    unsafe {
        let zip: *mut Zip = zip_open(path.as_ptr(), 5, mode);
        {
            zip_entry_open(zip, entryname.as_ptr());
            {
                let buf = content.as_ptr() as *const libc::c_void;
                let bufsize = content.len() as libc::size_t;
                zip_entry_write(zip, buf, bufsize);
            }
            zip_entry_close(zip);
        }
        zip_close(zip);
    }
 }
 ```
 ### Ruby (ffi)
 Install _ffi_ gem.
 ```shell
--- a/contrib/zip/src/zip.c
+++ b/contrib/zip/src/zip.c
@ -225,6 +225,20 @@ void zip_close(struct zip_t *zip) {
  }
 }
 int zip_is64(struct zip_t *zip) {
  if (!zip) {
    // zip_t handler is not initialized
    return -1;
  }
  if (!zip->archive.m_pState) {
    // zip state is not initialized
    return -1;
  }
  return (int)zip->archive.m_pState->m_zip64;
 }
 int zip_entry_open(struct zip_t *zip, const char *entryname) {
  size_t entrylen = 0;
  mz_zip_archive *pzip = NULL;
@ -797,7 +811,8 @@ int zip_create(const char *zipname, const char *filenames[], size_t len) {
    if (MZ_FILE_STAT(name, &file_stat) != 0) {
      // problem getting information - check errno
-      return -1;
+      status = -1;
      break;
    }
    if ((file_stat.st_mode & 0200) == 0) {
--- a/contrib/zip/src/zip.h
+++ b/contrib/zip/src/zip.h
@ -21,7 +21,7 @@ extern "C" {
 #if !defined(_SSIZE_T_DEFINED) && !defined(_SSIZE_T_DEFINED_) &&               \
    !defined(__DEFINED_ssize_t) && !defined(__ssize_t_defined) &&              \
-    !defined(_SSIZE_T) && !defined(_SSIZE_T_)
+    !defined(_SSIZE_T) && !defined(_SSIZE_T_) && !defined(_SSIZE_T_DECLARED)
 // 64-bit Windows is the only mainstream platform
 // where sizeof(long) != sizeof(void*)
@ -37,6 +37,7 @@ typedef long ssize_t; /* byte count or error */
 #define __ssize_t_defined
 #define _SSIZE_T
 #define _SSIZE_T_
 #define _SSIZE_T_DECLARED
 #endif
@ -90,6 +91,16 @@ extern struct zip_t *zip_open(const char *zipname, int level, char mode);
 */
 extern void zip_close(struct zip_t *zip);
 /**
 * Determines if the archive has a zip64 end of central directory headers.
 *
 * @param zip zip archive handler.
 *
 * @return the return code - 1 (true), 0 (false), negative number (< 0) on
 *         error.
 */
 extern int zip_is64(struct zip_t *zip);
 /**
 * Opens an entry by name in the zip archive.
 *
--- a/contrib/zip/test/CMakeLists.txt
+++ b/contrib/zip/test/CMakeLists.txt
@ -2,15 +2,10 @@ cmake_minimum_required(VERSION 2.8)
 # test
 set(test_out test.out)
 set(test_miniz_out test_miniz.out)
 add_executable(${test_out} test.c)
 target_link_libraries(${test_out} zip)
 add_executable(${test_miniz_out} test_miniz.c)
 target_link_libraries(${test_miniz_out} zip)
 add_test(NAME ${test_out} COMMAND ${test_out})
 add_test(NAME ${test_miniz_out} COMMAND ${test_miniz_out})
 set(test_out ${test_out} PARENT_SCOPE)
 set(test_miniz_out ${test_miniz_out} PARENT_SCOPE)
--- a/contrib/zip/test/test.c
+++ b/contrib/zip/test/test.c
@ -47,7 +47,7 @@ static void test_write(void) {
  assert(CRC32DATA1 == zip_entry_crc32(zip));
  ++total_entries;
  assert(0 == zip_entry_close(zip));
-
+  assert(0 == zip_is64(zip));
  zip_close(zip);
 }
@ -92,6 +92,7 @@ static void test_read(void) {
  size_t buftmp;
  struct zip_t *zip = zip_open(ZIPNAME, 0, 'r');
  assert(zip != NULL);
  assert(0 == zip_is64(zip));
  assert(0 == zip_entry_open(zip, "test\\test-1.txt"));
  assert(strlen(TESTDATA1) == zip_entry_size(zip));
@ -310,6 +311,7 @@ static void test_fwrite(void) {
  assert(0 == zip_entry_open(zip, WFILE));
  assert(0 == zip_entry_fwrite(zip, WFILE));
  assert(0 == zip_entry_close(zip));
  assert(0 == zip_is64(zip));
  zip_close(zip);
  remove(WFILE);
--- a/doc/CMakeLists.txt
+++ b/doc/CMakeLists.txt
@ -6,7 +6,7 @@ set( HTML_OUTPUT "AssimpDoc_Html" CACHE STRING "Output directory for generated H
 set( MICROSOFT_HELP_WORKSHOP "NO")
 if( MSVC )
    set( MICROSOFT_HELP_WORKSHOP "YES" )
-endif( MSVC )
+endif()
 configure_file(
    ${CMAKE_CURRENT_SOURCE_DIR}/Doxyfile.in
@ -38,5 +38,5 @@ if( DEFINED CMAKE_INSTALL_DOCDIR )
        ${CMAKE_CURRENT_SOURCE_DIR}/AssimpDoc_Html/dragonsplash.png
        DESTINATION ${CMAKE_INSTALL_DOCDIR}/${HTML_OUTPUT}
    )
-endif( DEFINED CMAKE_INSTALL_DOCDIR )
+endif()
--- a/include/assimp/GenericProperty.h
+++ b/include/assimp/GenericProperty.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,
@ -45,26 +44,25 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_GENERIC_PROPERTY_H_INCLUDED
 #ifdef __GNUC__
-#   pragma GCC system_header
+#    pragma GCC system_header
 #endif
 #include <assimp/Importer.hpp>
 #include <assimp/ai_assert.h>
 #include <assimp/Hash.h>
 #include <assimp/ai_assert.h>
 #include <assimp/Importer.hpp>
 #include <map>
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline
+inline bool SetGenericProperty(std::map<unsigned int, T> &list,
-bool SetGenericProperty(std::map< unsigned int, T >& list,
+        const char *szName, const T &value) {
        const char* szName, const T& value) {
    ai_assert(nullptr != szName);
    const uint32_t hash = SuperFastHash(szName);
    typename std::map<unsigned int, T>::iterator it = list.find(hash);
-    if (it == list.end())   {
+    if (it == list.end()) {
-        list.insert(std::pair<unsigned int, T>( hash, value ));
+        list.insert(std::pair<unsigned int, T>(hash, value));
        return false;
    }
    (*it).second = value;
@ -74,9 +72,8 @@ bool SetGenericProperty(std::map< unsigned int, T >& list,
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline
+inline const T &GetGenericProperty(const std::map<unsigned int, T> &list,
-const T& GetGenericProperty(const std::map< unsigned int, T >& list,
+        const char *szName, const T &errorReturn) {
        const char* szName, const T& errorReturn) {
    ai_assert(nullptr != szName);
    const uint32_t hash = SuperFastHash(szName);
@ -92,22 +89,21 @@ const T& GetGenericProperty(const std::map< unsigned int, T >& list,
 // Special version for pointer types - they will be deleted when replaced with another value
 // passing NULL removes the whole property
 template <class T>
-inline
+inline void SetGenericPropertyPtr(std::map<unsigned int, T *> &list,
-void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
+        const char *szName, T *value, bool *bWasExisting = nullptr) {
        const char* szName, T* value, bool* bWasExisting = nullptr ) {
    ai_assert(nullptr != szName);
    const uint32_t hash = SuperFastHash(szName);
-    typename std::map<unsigned int, T*>::iterator it = list.find(hash);
+    typename std::map<unsigned int, T *>::iterator it = list.find(hash);
-    if (it == list.end())   {
+    if (it == list.end()) {
        if (bWasExisting) {
            *bWasExisting = false;
        }
-        list.insert(std::pair<unsigned int,T*>( hash, value ));
+        list.insert(std::pair<unsigned int, T *>(hash, value));
        return;
    }
-    if ((*it).second != value)  {
+    if ((*it).second != value) {
        delete (*it).second;
        (*it).second = value;
    }
@ -121,9 +117,8 @@ void SetGenericPropertyPtr(std::map< unsigned int, T* >& list,
 // ------------------------------------------------------------------------------------------------
 template <class T>
-inline
+inline bool HasGenericProperty(const std::map<unsigned int, T> &list,
-bool HasGenericProperty(const std::map< unsigned int, T >& list,
+        const char *szName) {
        const char* szName) {
    ai_assert(nullptr != szName);
    const uint32_t hash = SuperFastHash(szName);
--- a/include/assimp/Importer.hpp
+++ b/include/assimp/Importer.hpp
@ -285,7 +285,7 @@ public:
     *  The return value remains valid until the property is modified.
     * @see GetPropertyInteger()
     */
-    const std::string GetPropertyString(const char* szName,
+    std::string GetPropertyString(const char* szName,
        const std::string& sErrorReturn = "") const;
    // -------------------------------------------------------------------
@ -294,7 +294,7 @@ public:
     *  The return value remains valid until the property is modified.
     * @see GetPropertyInteger()
     */
-    const aiMatrix4x4 GetPropertyMatrix(const char* szName,
+    aiMatrix4x4 GetPropertyMatrix(const char* szName,
        const aiMatrix4x4& sErrorReturn = aiMatrix4x4()) const;
    // -------------------------------------------------------------------
--- a/include/assimp/matrix3x3.h
+++ b/include/assimp/matrix3x3.h
@ -93,10 +93,10 @@ public:
    const TReal* operator[] (unsigned int p_iIndex) const;
    // comparison operators
-    bool operator== (const aiMatrix4x4t<TReal>& m) const;
+    bool operator== (const aiMatrix3x3t<TReal>& m) const;
-    bool operator!= (const aiMatrix4x4t<TReal>& m) const;
+    bool operator!= (const aiMatrix3x3t<TReal>& m) const;
-    bool Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon = 1e-6) const;
+    bool Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon = 1e-6) const;
    template <typename TOther>
    operator aiMatrix3x3t<TOther> () const;
--- a/include/assimp/matrix3x3.inl
+++ b/include/assimp/matrix3x3.inl
@ -141,7 +141,7 @@ const TReal* aiMatrix3x3t<TReal>::operator[] (unsigned int p_iIndex) const {
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE
-bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
+bool aiMatrix3x3t<TReal>::operator== (const aiMatrix3x3t<TReal>& m) const {
    return a1 == m.a1 && a2 == m.a2 && a3 == m.a3 &&
           b1 == m.b1 && b2 == m.b2 && b3 == m.b3 &&
           c1 == m.c1 && c2 == m.c2 && c3 == m.c3;
@ -150,14 +150,14 @@ bool aiMatrix3x3t<TReal>::operator== (const aiMatrix4x4t<TReal>& m) const {
 // ------------------------------------------------------------------------------------------------
 template <typename TReal>
 AI_FORCE_INLINE
-bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix4x4t<TReal>& m) const {
+bool aiMatrix3x3t<TReal>::operator!= (const aiMatrix3x3t<TReal>& m) const {
    return !(*this == m);
 }
 // ---------------------------------------------------------------------------
 template<typename TReal>
 AI_FORCE_INLINE
-bool aiMatrix3x3t<TReal>::Equal(const aiMatrix4x4t<TReal>& m, TReal epsilon) const {
+bool aiMatrix3x3t<TReal>::Equal(const aiMatrix3x3t<TReal>& m, TReal epsilon) const {
    return
        std::abs(a1 - m.a1) <= epsilon &&
        std::abs(a2 - m.a2) <= epsilon &&
--- a/port/PyAssimp/pyassimp/core.py
+++ b/port/PyAssimp/pyassimp/core.py
@ -138,7 +138,7 @@ def _init(self, target = None, parent = None):
            logger.debug(str(self) + ": Added array " + str(getattr(target, name)) +  " as self." + name.lower())
            continue
-        if m.startswith('m'):
+        if m.startswith('m') and len(m) > 1 and m[1].upper() == m[1]:
            if name == "parent":
                setattr(target, name, parent)
--- a/samples/SharedCode/UTFConverter.cpp
+++ b/samples/SharedCode/UTFConverter.cpp
@ -0,0 +1,52 @@
 /*
 ---------------------------------------------------------------------------
 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 "UTFConverter.h"
 namespace AssimpSamples {
 namespace SharedCode {
 typename UTFConverter::UTFConverterImpl UTFConverter::impl_;
 }
 }
--- a/samples/SharedCode/UTFConverter.h
+++ b/samples/SharedCode/UTFConverter.h
@ -0,0 +1,92 @@
 /*
 ---------------------------------------------------------------------------
 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_SAMPLES_SHARED_CODE_UTFCONVERTER_H
 #define ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
 #include <string>
 #include <locale>
 #include <codecvt>
 namespace AssimpSamples {
 namespace SharedCode {
 // Used to convert between multibyte and unicode strings.
 class UTFConverter {
    using UTFConverterImpl = std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>;
 public:
    UTFConverter(const char* s) :
        s_(s),
        ws_(impl_.from_bytes(s)) {
    }
    UTFConverter(const wchar_t* s) :
        s_(impl_.to_bytes(s)),
        ws_(s) {
    }
    UTFConverter(const std::string& s) :
        s_(s),
        ws_(impl_.from_bytes(s)) {
    }
    UTFConverter(const std::wstring& s) :
        s_(impl_.to_bytes(s)),
        ws_(s) {
    }
    inline const char* c_str() const {
        return s_.c_str();
    }
    inline const std::string& str() const {
        return s_;
    }
    inline const wchar_t* c_wstr() const {
        return ws_.c_str();
    }
 private:
    static UTFConverterImpl impl_;
    std::string s_;
    std::wstring ws_;
 };
 }
 }
 #endif // ASSIMP_SAMPLES_SHARED_CODE_UTFCONVERTER_H
--- a/samples/SimpleOpenGL/CMakeLists.txt
+++ b/samples/SimpleOpenGL/CMakeLists.txt
@ -2,24 +2,24 @@ FIND_PACKAGE(OpenGL)
 FIND_PACKAGE(GLUT)
 IF ( MSVC )
  SET(M_LIB)
-ELSE ( MSVC )
+ELSE ()
  find_library(M_LIB m)
-ENDIF ( MSVC )
+ENDIF ()
 IF ( NOT GLUT_FOUND )
  IF ( MSVC )
    SET ( GLUT_FOUND 1 )
    SET ( GLUT_INCLUDE_DIR ${Assimp_SOURCE_DIR}/samples/freeglut/ )
    SET ( GLUT_LIBRARIES ${Assimp_SOURCE_DIR}/samples/freeglut/lib/freeglut.lib )
-  ELSE ( MSVC )
+  ELSE ()
    MESSAGE( WARNING "Please install glut." )
-  ENDIF ( MSVC )
+  ENDIF ()
-ENDIF ( NOT GLUT_FOUND )
+ENDIF ()
 if ( MSVC )
  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
-endif ( MSVC )
+endif ()
 INCLUDE_DIRECTORIES(
  ${Assimp_SOURCE_DIR}/include
--- a/samples/SimpleTexturedDirectx11/CMakeLists.txt
+++ b/samples/SimpleTexturedDirectx11/CMakeLists.txt
@ -2,20 +2,20 @@ FIND_PACKAGE(DirectX)
 IF ( MSVC )
  SET(M_LIB)
-ENDIF ( MSVC )
+ENDIF ()
 if ( MSVC )
  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
  REMOVE_DEFINITIONS( -DUNICODE -D_UNICODE )
-endif ( MSVC )
+endif ()
 ADD_COMPILE_DEFINITIONS(SHADER_PATH="${CMAKE_CURRENT_SOURCE_DIR}/SimpleTexturedDirectx11/")
 INCLUDE_DIRECTORIES(
  ${Assimp_SOURCE_DIR}/include
  ${Assimp_SOURCE_DIR}/code
-  ${OPENGL_INCLUDE_DIR}
+  ${SAMPLES_SHARED_CODE_DIR}
  ${GLUT_INCLUDE_DIR}
  ${Assimp_SOURCE_DIR}/samples/freeglut/include
 )
 LINK_DIRECTORIES(
@ -32,11 +32,14 @@ ADD_EXECUTABLE( assimp_simpletextureddirectx11 WIN32
  SimpleTexturedDirectx11/TextureLoader.h 
  #SimpleTexturedDirectx11/VertexShader.hlsl  
  SimpleTexturedDirectx11/main.cpp
  SimpleTexturedDirectx11/SafeRelease.hpp
  ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.cpp
  ${SAMPLES_SHARED_CODE_DIR}/UTFConverter.h
 )
 SET_PROPERTY(TARGET assimp_simpletextureddirectx11 PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
-TARGET_LINK_LIBRARIES( assimp_simpletextureddirectx11 assimp ${DirectX_LIBRARY} comctl32.lib winmm.lib )
+TARGET_LINK_LIBRARIES( assimp_simpletextureddirectx11 assimp comctl32.lib winmm.lib )
 SET_TARGET_PROPERTIES( assimp_simpletextureddirectx11 PROPERTIES
  OUTPUT_NAME assimp_simpletextureddirectx11
 )
--- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h
+++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/Mesh.h
@ -6,97 +6,102 @@
 #include <sstream>
 #include <iostream>
 #include <vector>
-using namespace std;
+#include <stdexcept>
 #include <vector>
 #include <d3d11_1.h>
 #include <DirectXMath.h>
 using namespace DirectX;
 #include "SafeRelease.hpp"
 struct VERTEX {
 	FLOAT X, Y, Z;
 	XMFLOAT2 texcoord;
 };
 struct Texture {
-	string type;
+	std::string type;
-	string path;
+	std::string path;
 	ID3D11ShaderResourceView *texture;
 	void Release() {
 		SafeRelease(texture);
 	}
 };
 class Mesh {
 public:
-	vector<VERTEX> vertices;
+    std::vector<VERTEX> vertices;
-	vector<UINT> indices;
+    std::vector<UINT> indices;
-	vector<Texture> textures;
+    std::vector<Texture> textures;
-	ID3D11Device *dev;
+    ID3D11Device *dev;
-	Mesh(ID3D11Device *dev, vector<VERTEX> vertices, vector<UINT> indices, vector<Texture> textures)
+    Mesh(ID3D11Device *dev, const std::vector<VERTEX>& vertices, const std::vector<UINT>& indices, const std::vector<Texture>& textures) :
-	{
+            vertices(vertices),
-		this->vertices = vertices;
+            indices(indices),
-		this->indices = indices;
+            textures(textures),
-		this->textures = textures;
+            dev(dev),
            VertexBuffer(nullptr),
            IndexBuffer(nullptr) {
        this->setupMesh(this->dev);
    }
-		this->dev = dev;
+    void Draw(ID3D11DeviceContext *devcon) {
        UINT stride = sizeof(VERTEX);
        UINT offset = 0;
-		this->setupMesh(dev);
+        devcon->IASetVertexBuffers(0, 1, &VertexBuffer, &stride, &offset);
-	}
+        devcon->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0);
-	void Draw(ID3D11DeviceContext *devcon)
+        devcon->PSSetShaderResources(0, 1, &textures[0].texture);
 	{
 		UINT stride = sizeof(VERTEX);
 		UINT offset = 0;
-		devcon->IASetVertexBuffers(0, 1, &VertexBuffer, &stride, &offset);
+        devcon->DrawIndexed(static_cast<UINT>(indices.size()), 0, 0);
-		devcon->IASetIndexBuffer(IndexBuffer, DXGI_FORMAT_R32_UINT, 0);
+    }
-		devcon->PSSetShaderResources(0, 1, &textures[0].texture);
+    void Close() {
-
+        SafeRelease(VertexBuffer);
-		devcon->DrawIndexed(indices.size(), 0, 0);
+        SafeRelease(IndexBuffer);
-	}
+    }
 	void Close()
 	{
 		VertexBuffer->Release();
 		IndexBuffer->Release();
 	}
 private:
-	/*  Render data  */
+    // Render data
-	ID3D11Buffer *VertexBuffer, *IndexBuffer;
+    ID3D11Buffer *VertexBuffer, *IndexBuffer;
-	/*  Functions    */
+    // Functions
-	// Initializes all the buffer objects/arrays
+    // Initializes all the buffer objects/arrays
-	bool setupMesh(ID3D11Device *dev)
+    void setupMesh(ID3D11Device *dev) {
-	{
+        HRESULT hr;
 		HRESULT hr;
-		D3D11_BUFFER_DESC vbd;
+        D3D11_BUFFER_DESC vbd;
-		vbd.Usage = D3D11_USAGE_IMMUTABLE;
+        vbd.Usage = D3D11_USAGE_IMMUTABLE;
-		vbd.ByteWidth = sizeof(VERTEX) * vertices.size();
+        vbd.ByteWidth = static_cast<UINT>(sizeof(VERTEX) * vertices.size());
-		vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
+        vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
-		vbd.CPUAccessFlags = 0;
+        vbd.CPUAccessFlags = 0;
-		vbd.MiscFlags = 0;
+        vbd.MiscFlags = 0;
-		D3D11_SUBRESOURCE_DATA initData;
+        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))
+        if (FAILED(hr)) {
-			return false;
+            Close();
            throw std::runtime_error("Failed to create vertex buffer.");
        }
-		D3D11_BUFFER_DESC ibd;
+        D3D11_BUFFER_DESC ibd;
-		ibd.Usage = D3D11_USAGE_IMMUTABLE;
+        ibd.Usage = D3D11_USAGE_IMMUTABLE;
-		ibd.ByteWidth = sizeof(UINT) * indices.size();
+        ibd.ByteWidth = static_cast<UINT>(sizeof(UINT) * indices.size());
-		ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
+        ibd.BindFlags = D3D11_BIND_INDEX_BUFFER;
-		ibd.CPUAccessFlags = 0;
+        ibd.CPUAccessFlags = 0;
-		ibd.MiscFlags = 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))
+        if (FAILED(hr)) {
-			return false;
+            Close();
-	}
+            throw std::runtime_error("Failed to create index buffer.");
        }
    }
 };
 #endif
--- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp
+++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.cpp
@ -1,16 +1,21 @@
 #include "ModelLoader.h"
-ModelLoader::ModelLoader()
+ModelLoader::ModelLoader() : 
-{
+        dev(nullptr),
        devcon(nullptr),
        meshes(),
        directory(),
        textures_loaded(),
        hwnd(nullptr) {
    // empty
 }
-ModelLoader::~ModelLoader()
+ModelLoader::~ModelLoader() {
-{
+    // empty
 }
-bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devcon, std::string filename)
+bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devcon, std::string filename) {
 {
 	Assimp::Importer importer;
 	const aiScene* pScene = importer.ReadFile(filename,
@ -20,9 +25,10 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
 	if (pScene == NULL)
 		return false;
-	this->directory = filename.substr(0, filename.find_last_of('/'));
+	this->directory = filename.substr(0, filename.find_last_of("/\\"));
 	this->dev = dev;
 	this->devcon = devcon;
 	this->hwnd = hwnd;
 	processNode(pScene->mRootNode, pScene);
@ -30,41 +36,37 @@ bool ModelLoader::Load(HWND hwnd, ID3D11Device * dev, ID3D11DeviceContext * devc
 	return true;
 }
-void ModelLoader::Draw(ID3D11DeviceContext * devcon)
+void ModelLoader::Draw(ID3D11DeviceContext * devcon) {
-{
+	for (int i = 0; i < meshes.size(); ++i ) {
 	for (int i = 0; i < meshes.size(); i++)
 	{
 		meshes[i].Draw(devcon);
 	}
 }
-string textype;
+std::string textype;
-Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene)
+Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene) {
 {
 	// Data to fill
-	vector<VERTEX> vertices;
+	std::vector<VERTEX> vertices;
-	vector<UINT> indices;
+	std::vector<UINT> indices;
-	vector<Texture> textures;
+	std::vector<Texture> textures;
-	if (mesh->mMaterialIndex >= 0)
+	if (mesh->mMaterialIndex >= 0) {
 	{
 		aiMaterial* mat = scene->mMaterials[mesh->mMaterialIndex];
-		if (textype.empty()) textype = determineTextureType(scene, mat);
+		if (textype.empty()) {
            textype = determineTextureType(scene, mat);
        }
 	}
 	// Walk through each of the mesh's vertices
-	for (UINT i = 0; i < mesh->mNumVertices; i++)
+	for (UINT i = 0; i < mesh->mNumVertices; i++) {
 	{
 		VERTEX vertex;
 		vertex.X = mesh->mVertices[i].x;
 		vertex.Y = mesh->mVertices[i].y;
 		vertex.Z = mesh->mVertices[i].z;
-		if (mesh->mTextureCoords[0])
+		if (mesh->mTextureCoords[0]) {
 		{
 			vertex.texcoord.x = (float)mesh->mTextureCoords[0][i].x;
 			vertex.texcoord.y = (float)mesh->mTextureCoords[0][i].y;
 		}
@ -72,57 +74,47 @@ Mesh ModelLoader::processMesh(aiMesh * mesh, const aiScene * scene)
 		vertices.push_back(vertex);
 	}
-	for (UINT i = 0; i < mesh->mNumFaces; i++)
+	for (UINT i = 0; i < mesh->mNumFaces; i++) {
 	{
 		aiFace face = mesh->mFaces[i];
 		for (UINT j = 0; j < face.mNumIndices; j++)
 			indices.push_back(face.mIndices[j]);
 	}
-	if (mesh->mMaterialIndex >= 0)
+	if (mesh->mMaterialIndex >= 0) {
 	{
 		aiMaterial* material = scene->mMaterials[mesh->mMaterialIndex];
-		vector<Texture> diffuseMaps = this->loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse", scene);
+		std::vector<Texture> diffuseMaps = this->loadMaterialTextures(material, aiTextureType_DIFFUSE, "texture_diffuse", scene);
 		textures.insert(textures.end(), diffuseMaps.begin(), diffuseMaps.end());
 	}
 	return Mesh(dev, vertices, indices, textures);
 }
-vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, string typeName, const aiScene * scene)
+std::vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureType type, std::string typeName, const aiScene * scene) {
-{
+	std::vector<Texture> textures;
-	vector<Texture> textures;
+	for (UINT i = 0; i < mat->GetTextureCount(type); i++) {
 	for (UINT i = 0; i < mat->GetTextureCount(type); i++)
 	{
 		aiString str;
 		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]);
 				skip = true; // A texture with the same filepath has already been loaded, continue to next one. (optimization)
 				break;
 			}
 		}
-		if (!skip)
+		if (!skip) {   // If texture hasn't been loaded already, load it
 		{   // If texture hasn't been loaded already, load it
 			HRESULT hr;
 			Texture texture;
-			if (textype == "embedded compressed texture")
+			if (textype == "embedded compressed texture") {
 			{
 				int textureindex = getTextureIndex(&str);
 				texture.texture = getTextureFromModel(scene, textureindex);
-			}
+			} else {
-			else
+				std::string filename = std::string(str.C_Str());
 			{
 				string filename = string(str.C_Str());
 				filename = directory + '/' + filename;
-				wstring filenamews = wstring(filename.begin(), filename.end());
+				std::wstring filenamews = std::wstring(filename.begin(), filename.end());
 				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);
@ -136,64 +128,52 @@ vector<Texture> ModelLoader::loadMaterialTextures(aiMaterial * mat, aiTextureTyp
 	return textures;
 }
-void ModelLoader::Close()
+void ModelLoader::Close() {
-{
+	for (auto& t : textures_loaded)
-	for (int i = 0; i < meshes.size(); i++)
+		t.Release();
-	{
+
 	for (int i = 0; i < meshes.size(); i++) {
 		meshes[i].Close();
 	}
 	dev->Release();
 }
-void ModelLoader::processNode(aiNode * node, const aiScene * scene)
+void ModelLoader::processNode(aiNode * node, const aiScene * scene) {
-{
+	for (UINT i = 0; i < node->mNumMeshes; i++) {
 	for (UINT i = 0; i < node->mNumMeshes; i++)
 	{
 		aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
 		meshes.push_back(this->processMesh(mesh, scene));
 	}
-	for (UINT i = 0; i < node->mNumChildren; i++)
+	for (UINT i = 0; i < node->mNumChildren; i++) {
 	{
 		this->processNode(node->mChildren[i], scene);
 	}
 }
-string ModelLoader::determineTextureType(const aiScene * scene, aiMaterial * mat)
+std::string ModelLoader::determineTextureType(const aiScene * scene, aiMaterial * mat) {
 {
 	aiString textypeStr;
 	mat->GetTexture(aiTextureType_DIFFUSE, 0, &textypeStr);
-	string textypeteststr = textypeStr.C_Str();
+	std::string textypeteststr = textypeStr.C_Str();
-	if (textypeteststr == "*0" || textypeteststr == "*1" || textypeteststr == "*2" || textypeteststr == "*3" || textypeteststr == "*4" || textypeteststr == "*5")
+	if (textypeteststr == "*0" || textypeteststr == "*1" || textypeteststr == "*2" || textypeteststr == "*3" || textypeteststr == "*4" || textypeteststr == "*5") {
-	{
+		if (scene->mTextures[0]->mHeight == 0) {
 		if (scene->mTextures[0]->mHeight == 0)
 		{
 			return "embedded compressed texture";
-		}
+		} else {
 		else
 		{
 			return "embedded non-compressed texture";
 		}
 	}
-	if (textypeteststr.find('.') != string::npos)
+	if (textypeteststr.find('.') != std::string::npos) {
 	{
 		return "textures are on disk";
 	}
    return ".";
 }
-int ModelLoader::getTextureIndex(aiString * str)
+int ModelLoader::getTextureIndex(aiString * str) {
-{
+	std::string tistr;
 	string tistr;
 	tistr = str->C_Str();
 	tistr = tistr.substr(1);
 	return stoi(tistr);
 }
-ID3D11ShaderResourceView * ModelLoader::getTextureFromModel(const aiScene * scene, int textureindex)
+ID3D11ShaderResourceView * ModelLoader::getTextureFromModel(const aiScene * scene, int textureindex) {
 {
 	HRESULT hr;
 	ID3D11ShaderResourceView *texture;
--- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h
+++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/ModelLoader.h
@ -28,14 +28,14 @@ private:
 	ID3D11Device *dev;
 	ID3D11DeviceContext *devcon;
 	std::vector<Mesh> meshes;
-	string directory;
+	std::string directory;
-	vector<Texture> textures_loaded;
+	std::vector<Texture> textures_loaded;
 	HWND hwnd;
 	void processNode(aiNode* node, const aiScene* scene);
 	Mesh processMesh(aiMesh* mesh, const aiScene* scene);
-	vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, string typeName, const aiScene* scene);
+	std::vector<Texture> loadMaterialTextures(aiMaterial* mat, aiTextureType type, std::string typeName, const aiScene* scene);
-	string determineTextureType(const aiScene* scene, aiMaterial* mat);
+	std::string determineTextureType(const aiScene* scene, aiMaterial* mat);
 	int getTextureIndex(aiString* str);
 	ID3D11ShaderResourceView* getTextureFromModel(const aiScene* scene, int textureindex);
 };
--- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/SafeRelease.hpp
+++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/SafeRelease.hpp
@ -0,0 +1,57 @@
 /*
 ---------------------------------------------------------------------------
 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.
 ---------------------------------------------------------------------------
 */
 #ifdef _MSC_VER
 #pragma once
 #endif
 /* Used to reduce to reduce the number of lines when calling Release()
   on a D3D interface. Implemented as a template instead of a 'SAFE_RELEASE'
   MACRO to ease debugging. */
 template<typename T>
 inline void SafeRelease(T*& x) {
    if (x) {
        x->Release();
        x = nullptr;
    }
 }
--- a/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
+++ b/samples/SimpleTexturedDirectx11/SimpleTexturedDirectx11/main.cpp
@ -14,12 +14,16 @@
 // ---------------------------------------------------------------------------
 #include <Windows.h>
 #include <shellapi.h>
 #include <stdexcept>
 #include <windowsx.h>
 #include <d3d11_1.h>
 #include <dxgi1_2.h>
 #include <DirectXMath.h>
 #include <d3dcompiler.h>
 #include "ModelLoader.h"
 #include "UTFConverter.h"
 #include "SafeRelease.hpp"
 #pragma comment (lib, "d3d11.lib")
 #pragma comment (lib, "Dxgi.lib")
@ -27,6 +31,10 @@
 #pragma comment (lib, "dxguid.lib")
 using namespace DirectX;
 using namespace AssimpSamples::SharedCode;
 #define VERTEX_SHADER_FILE L"VertexShader.hlsl"
 #define PIXEL_SHADER_FILE L"PixelShader.hlsl"
 // ------------------------------------------------------------
 //                        Structs
@ -45,29 +53,32 @@ struct ConstantBuffer {
 const char g_szClassName[] = "directxWindowClass";
 static std::string g_ModelPath;
 UINT width, height;
-HWND hwnd;
+HWND hwnd = nullptr;
 // ------------------------------------------------------------
 //                        DirectX Variables
 // ------------------------------------------------------------
 D3D_DRIVER_TYPE g_driverType = D3D_DRIVER_TYPE_NULL;
 D3D_FEATURE_LEVEL g_featureLevel = D3D_FEATURE_LEVEL_11_0;
-ID3D11Device *dev;
+ID3D11Device *dev = nullptr;
-ID3D11Device1 *dev1;
+ID3D11Device1 *dev1 = nullptr;
-ID3D11DeviceContext *devcon;
+ID3D11DeviceContext *devcon = nullptr;
-ID3D11DeviceContext1 *devcon1;
+ID3D11DeviceContext1 *devcon1 = nullptr;
-IDXGISwapChain *swapchain;
+IDXGISwapChain *swapchain = nullptr;
-IDXGISwapChain1 *swapchain1;
+IDXGISwapChain1 *swapchain1 = nullptr;
-ID3D11RenderTargetView *backbuffer;
+ID3D11RenderTargetView *backbuffer = nullptr;
-ID3D11VertexShader *pVS;
+ID3D11VertexShader *pVS = nullptr;
-ID3D11PixelShader *pPS;
+ID3D11PixelShader *pPS = nullptr;
-ID3D11InputLayout *pLayout;
+ID3D11InputLayout *pLayout = nullptr;
-ID3D11Buffer *pConstantBuffer;
+ID3D11Buffer *pConstantBuffer = nullptr;
-ID3D11Texture2D *g_pDepthStencil;
+ID3D11Texture2D *g_pDepthStencil = nullptr;
-ID3D11DepthStencilView *g_pDepthStencilView;
+ID3D11DepthStencilView *g_pDepthStencilView = nullptr;
-ID3D11SamplerState *TexSamplerState;
+ID3D11SamplerState *TexSamplerState = nullptr;
 ID3D11RasterizerState *rasterstate = nullptr;
 ID3D11Debug* d3d11debug = nullptr;
 XMMATRIX m_World;
 XMMATRIX m_View;
@ -91,7 +102,7 @@ void Throwanerror(LPCSTR errormessage);
 //                        Our Model
 // ------------------------------------------------------------
-ModelLoader *ourModel;
+ModelLoader *ourModel = nullptr;
 LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
@ -109,9 +120,42 @@ LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
 	return 0;
 }
-int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
+int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
-	LPSTR lpCmdLine, int nCmdShow)
+	LPWSTR lpCmdLine, int nCmdShow)
 {
 	int argc;
 	LPWSTR* argv = CommandLineToArgvW(GetCommandLineW(), &argc);
 	if (!argv) {
 		MessageBox(NULL, 
 			TEXT("An error occured while reading command line arguments."),
 			TEXT("Error!"),
 			MB_ICONERROR | MB_OK);
 		return EXIT_FAILURE;
 	}
 	// Free memory allocated from CommandLineToArgvW.
 	auto free_command_line_allocated_memory = [&argv]() {
 		if (argv) {
 			LocalFree(argv);
 			argv = nullptr;
 		}
 	};
 	// Ensure that a model file has been specified.
 	if (argc < 2) {
 		MessageBox(NULL, 
 			TEXT("No model file specified. The program will now close."), 
 			TEXT("Error!"),
 			MB_ICONERROR | MB_OK);
 		free_command_line_allocated_memory();
 		return EXIT_FAILURE;
 	}
 	// Retrieve the model file path.
 	g_ModelPath = UTFConverter(argv[1]).str();
 	free_command_line_allocated_memory();
 	WNDCLASSEX wc;
 	MSG msg;
@ -160,26 +204,35 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
 	width = wr.right - wr.left;
 	height = wr.bottom - wr.top;
-	InitD3D(hInstance, hwnd);
+	try {
 		InitD3D(hInstance, hwnd);
-	while (true)
+		while (true)
 	{
 		if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
 		{
 			TranslateMessage(&msg);
 			DispatchMessage(&msg);
-			if (msg.message == WM_QUIT)
+			if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
-				break;
+			{
 				TranslateMessage(&msg);
 				DispatchMessage(&msg);
 				if (msg.message == WM_QUIT)
 					break;
 			}
 			RenderFrame();
 		}
-		RenderFrame();
+		CleanD3D();
 		return static_cast<int>(msg.wParam);
 	} catch (const std::exception& e) {
 		MessageBox(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);
 		CleanD3D();
 		return EXIT_FAILURE;
 	}
 	CleanD3D();
 	return msg.wParam;
 }
 void InitD3D(HINSTANCE hinstance, HWND hWnd)
@ -227,6 +280,12 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
 	if (FAILED(hr))
 		Throwanerror("Directx Device Creation Failed!");
 #if _DEBUG
 	hr = dev->QueryInterface(IID_PPV_ARGS(&d3d11debug));
 	if (FAILED(hr))
 		OutputDebugString(TEXT("Failed to retrieve DirectX 11 debug interface.\n"));
 #endif
 	UINT m4xMsaaQuality;
 	dev->CheckMultisampleQualityLevels(
 		DXGI_FORMAT_R8G8B8A8_UNORM, 4, &m4xMsaaQuality);
@ -348,7 +407,6 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
 	devcon->OMSetRenderTargets(1, &backbuffer, g_pDepthStencilView);
 	D3D11_RASTERIZER_DESC rasterDesc;
 	ID3D11RasterizerState *rasterState;
 	rasterDesc.AntialiasedLineEnable = false;
 	rasterDesc.CullMode = D3D11_CULL_BACK;
 	rasterDesc.DepthBias = 0;
@ -360,8 +418,8 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
 	rasterDesc.ScissorEnable = false;
 	rasterDesc.SlopeScaledDepthBias = 0.0f;
-	dev->CreateRasterizerState(&rasterDesc, &rasterState);
+	dev->CreateRasterizerState(&rasterDesc, &rasterstate);
-	devcon->RSSetState(rasterState);
+	devcon->RSSetState(rasterstate);
 	D3D11_VIEWPORT viewport;
 	ZeroMemory(&viewport, sizeof(D3D11_VIEWPORT));
@ -381,19 +439,38 @@ void InitD3D(HINSTANCE hinstance, HWND hWnd)
 void CleanD3D(void)
 {
-	swapchain->SetFullscreenState(FALSE, NULL);
+	if (swapchain)
 		swapchain->SetFullscreenState(FALSE, NULL);
-	ourModel->Close();
+	if (ourModel) {
-	g_pDepthStencil->Release();
+		ourModel->Close();
-	g_pDepthStencilView->Release();
+		delete ourModel;
-	pLayout->Release();
+		ourModel = nullptr;
-	pVS->Release();
+	}
-	pPS->Release();
+	SafeRelease(TexSamplerState);
-	pConstantBuffer->Release();
+	SafeRelease(pConstantBuffer);
-	swapchain->Release();
+	SafeRelease(pLayout);
-	backbuffer->Release();
+	SafeRelease(pVS);
-	dev->Release();
+	SafeRelease(pPS);
-	devcon->Release();
+	SafeRelease(rasterstate);
 	SafeRelease(g_pDepthStencilView);
 	SafeRelease(g_pDepthStencil);
 	SafeRelease(backbuffer);
 	SafeRelease(swapchain);
 	SafeRelease(swapchain1);
 	SafeRelease(devcon1);
 	SafeRelease(dev1);
 	SafeRelease(devcon);
 #if _DEBUG
 	if (d3d11debug) {
 		OutputDebugString(TEXT("Dumping DirectX 11 live objects.\n"));
 		d3d11debug->ReportLiveDeviceObjects(D3D11_RLDO_DETAIL);
 		SafeRelease(d3d11debug);
 	} else {
 		OutputDebugString(TEXT("Unable to dump live objects: no DirectX 11 debug interface available.\n"));
 	}
 #endif
 	SafeRelease(dev);
 }
 void RenderFrame(void)
@ -431,8 +508,10 @@ void RenderFrame(void)
 void InitPipeline()
 {
 	ID3DBlob *VS, *PS;
-	CompileShaderFromFile(L"VertexShader.hlsl", 0, "main", "vs_4_0", &VS);
+	if(FAILED(CompileShaderFromFile(SHADER_PATH VERTEX_SHADER_FILE, 0, "main", "vs_4_0", &VS)))
-	CompileShaderFromFile(L"PixelShader.hlsl", 0, "main", "ps_4_0", &PS);
+		Throwanerror(UTFConverter(L"Failed to compile shader from file " VERTEX_SHADER_FILE).c_str());
 	if(FAILED(CompileShaderFromFile(SHADER_PATH PIXEL_SHADER_FILE, 0, "main", "ps_4_0", &PS)))
 		Throwanerror(UTFConverter(L"Failed to compile shader from file " PIXEL_SHADER_FILE).c_str());
 	dev->CreateVertexShader(VS->GetBufferPointer(), VS->GetBufferSize(), NULL, &pVS);
 	dev->CreatePixelShader(PS->GetBufferPointer(), PS->GetBufferSize(), NULL, &pPS);
@ -485,7 +564,7 @@ void InitGraphics()
 	m_View = XMMatrixLookAtLH(Eye, At, Up);
 	ourModel = new ModelLoader;
-	if (!ourModel->Load(hwnd, dev, devcon, "Models/myModel.fbx"))
+	if (!ourModel->Load(hwnd, dev, devcon, g_ModelPath))
 		Throwanerror("Model couldn't be loaded");
 }
@ -514,5 +593,5 @@ HRESULT	CompileShaderFromFile(LPCWSTR pFileName, const D3D_SHADER_MACRO* pDefine
 void Throwanerror(LPCSTR errormessage)
 {
-	MessageBox(hwnd, errormessage, "Error!", MB_ICONERROR | MB_OK);
+	throw std::runtime_error(errormessage);
-}
+}
--- a/samples/SimpleTexturedOpenGL/CMakeLists.txt
+++ b/samples/SimpleTexturedOpenGL/CMakeLists.txt
@ -6,21 +6,22 @@ IF ( NOT GLUT_FOUND )
    SET ( GLUT_FOUND 1 )
    SET ( GLUT_INCLUDE_DIR ${Assimp_SOURCE_DIR}/samples/freeglut/ )
    SET ( GLUT_LIBRARIES ${Assimp_SOURCE_DIR}/samples/freeglut/lib/freeglut.lib )
-  ELSE ( MSVC )
+  ELSE ()
    MESSAGE( WARNING "Please install glut." )
-  ENDIF ( MSVC )
+  ENDIF ()
-ENDIF ( NOT GLUT_FOUND )
+ENDIF ()
 if ( MSVC )
  ADD_DEFINITIONS( -D_SCL_SECURE_NO_WARNINGS )
  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
-endif ( MSVC )
+endif ()
 INCLUDE_DIRECTORIES(
  ${Assimp_SOURCE_DIR}/include
  ${Assimp_SOURCE_DIR}/code
  ${OPENGL_INCLUDE_DIR}
  ${GLUT_INCLUDE_DIR}
  ${SAMPLES_SHARED_CODE_DIR}
 )
 LINK_DIRECTORIES(
@ -31,6 +32,8 @@ 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
 )
 SET_PROPERTY(TARGET assimp_simpletexturedogl PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
--- a/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp
+++ b/samples/SimpleTexturedOpenGL/SimpleTexturedOpenGL/src/model_loading.cpp
@ -21,8 +21,6 @@
 #define STB_IMAGE_IMPLEMENTATION
 #include "contrib/stb_image/stb_image.h"
 #include <locale>
 #include <codecvt>
 #include <fstream>
 //to map image filenames to textureIds
@ -35,7 +33,7 @@
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/LogStream.hpp>
-
+#include "UTFConverter.h"
 // 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";
@ -77,35 +75,7 @@ GLuint*		textureIds;							// pointer to texture Array
 // Create an instance of the Importer class
 Assimp::Importer importer;
-// Used to convert between multibyte and unicode strings.
+using namespace AssimpSamples::SharedCode;
 class UTFConverter {
 	using UTFConverterImpl = std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t>;
 public:
 	UTFConverter(const char* s) :
 		s_(s),
 		ws_(impl_.from_bytes(s)) {
 	}
 	UTFConverter(const std::string& s) :
 		s_(s),
 		ws_(impl_.from_bytes(s)) {
 	}
 	UTFConverter(const std::wstring& s) :
 		s_(impl_.to_bytes(s)),
 		ws_(s) {
 	}
 	inline const std::string& str() const {
 		return s_;
 	}
 	inline const wchar_t* c_wstr() const {
 		return ws_.c_str();
 	}
 private:
 	static UTFConverterImpl impl_;
 	std::string s_;
 	std::wstring ws_;
 };
 typename UTFConverter::UTFConverterImpl UTFConverter::impl_;
 void createAILogger()
 {
@ -202,8 +172,21 @@ std::string getBasePath(const std::string& path)
 	return (std::string::npos == pos) ? "" : path.substr(0, pos + 1);
 }
 void freeTextureIds()
 {
 	textureIdMap.clear(); //no need to delete pointers in it manually here. (Pointers point to textureIds deleted in next step)
 	if (textureIds)
 	{
 		delete[] textureIds;
 		textureIds = NULL;
 	}
 }
 int LoadGLTextures(const aiScene* scene)
 {
 	freeTextureIds();
 	//ILboolean success;
 	/* Before calling ilInit() version should be checked. */
@ -576,21 +559,24 @@ void KillGLWindow()			// Properly Kill The Window
 		hRC = NULL;
 	}
-	if (hDC && !ReleaseDC(hWnd, hDC))	// Are We able to Release The DC?
+	if (hDC)
 	{
-		MessageBox(NULL, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+		if (!ReleaseDC(hWnd, hDC)) // Are We able to Release The DC?
-		hDC=NULL;
+			MessageBox(NULL, TEXT("Release Device Context Failed."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
 		hDC = NULL;
 	}
-	if (hWnd && !DestroyWindow(hWnd))	// Are We Able To Destroy The Window
+	if (hWnd)
 	{
-		MessageBox(NULL, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+		if (!DestroyWindow(hWnd)) // Are We Able To Destroy The Window
 			MessageBox(NULL, TEXT("Could Not Release hWnd."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
 		hWnd = NULL;
-	}
+	} 
-	if (!UnregisterClass(TEXT("OpenGL"), hInstance))	// Are We Able To Unregister Class
+	if (hInstance)
 	{
-		MessageBox(NULL, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
+		if (!UnregisterClass(TEXT("OpenGL"), hInstance)) // Are We Able To Unregister Class
 			MessageBox(NULL, TEXT("Could Not Unregister Class."), TEXT("SHUTDOWN ERROR"), MB_OK | MB_ICONINFORMATION);
 		hInstance = NULL;
 	}
 }
@ -761,6 +747,16 @@ BOOL CreateGLWindow(const char* title, int width, int height, int bits, bool ful
 	return TRUE;
 }
 void cleanup()
 {
 	freeTextureIds();
 	destroyAILogger();
 	if (hWnd)
 		KillGLWindow();
 };
 LRESULT CALLBACK WndProc(HWND hWnd,				// Handles for this Window
 						 UINT uMsg,				// Message for this Window
 						 WPARAM wParam,			// additional message Info
@ -842,7 +838,11 @@ int WINAPI WinMain( HINSTANCE hInstance,         // The instance
 		modelpath = UTFConverter(modelpathW).str();
 	}
-	if (!Import3DFromFile(modelpath)) return 0;
+	if (!Import3DFromFile(modelpath))
 	{
 		cleanup();
 		return 0;
 	}
 	logInfo("=============== Post Import ====================");
@ -853,6 +853,7 @@ int WINAPI WinMain( HINSTANCE hInstance,         // The instance
 	if (!CreateGLWindow(windowTitle, 640, 480, 16, fullscreen))
 	{
 		cleanup();
 		return 0;
 	}
@ -893,6 +894,7 @@ int WINAPI WinMain( HINSTANCE hInstance,         // The instance
 				fullscreen=!fullscreen;
 				if (!CreateGLWindow(windowTitle, 640, 480, 16, fullscreen))
 				{
 					cleanup();
 					return 0;
 				}
 			}
@ -900,18 +902,6 @@ int WINAPI WinMain( HINSTANCE hInstance,         // The instance
 	}
 	// *** cleanup ***
-
+	cleanup();
 	textureIdMap.clear(); //no need to delete pointers in it manually here. (Pointers point to textureIds deleted in next step)
 	if (textureIds)
 	{
 		delete[] textureIds;
 		textureIds = NULL;
 	}
 	// *** cleanup end ***
 	destroyAILogger();
 	KillGLWindow();
 	return static_cast<int>(msg.wParam);
 }
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@ -201,20 +201,13 @@ SET_PROPERTY( TARGET assimp PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX} )
 IF( WIN32 )
    SET( platform_libs )
-ELSE( WIN32 )
+ELSE()
    SET( platform_libs pthread )
-ENDIF( WIN32 )
+ENDIF()
 IF( WIN32 )
  ADD_CUSTOM_COMMAND(TARGET unit
    PRE_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:assimp> $<TARGET_FILE_DIR:unit>
    MAIN_DEPENDENCY assimp)
 ENDIF( WIN32 )
 IF(MSVC)
 		add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-ENDIF(MSVC)
+ENDIF()
 target_link_libraries( unit assimp ${platform_libs} )
--- a/test/headercheck/CMakeLists.txt
+++ b/test/headercheck/CMakeLists.txt
@ -30,7 +30,7 @@ FOREACH( HEADER ${headers} )
  # add library
  add_library( ${TEST_NAME} EXCLUDE_FROM_ALL ${TEST_FILE} )
  list(APPEND headerchecklibs ${TEST_NAME})
-ENDFOREACH( HEADER )
+ENDFOREACH()
 add_custom_target(headercheck DEPENDS ${headerchecklibs})
--- a/tools/assimp_cmd/CMakeLists.txt
+++ b/tools/assimp_cmd/CMakeLists.txt
@ -37,7 +37,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 #----------------------------------------------------------------------
-cmake_minimum_required( VERSION 2.6 )
+cmake_minimum_required( VERSION 3.0 )
 INCLUDE_DIRECTORIES(
  ${Assimp_SOURCE_DIR}/include
@ -61,13 +61,6 @@ ADD_EXECUTABLE( assimp_cmd
 SET_PROPERTY(TARGET assimp_cmd PROPERTY DEBUG_POSTFIX ${CMAKE_DEBUG_POSTFIX})
 IF( WIN32 )
  ADD_CUSTOM_COMMAND(TARGET assimp_cmd
    PRE_BUILD
    COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:assimp> $<TARGET_FILE_DIR:assimp_cmd>
    MAIN_DEPENDENCY assimp)
 ENDIF( WIN32 )
 TARGET_LINK_LIBRARIES( assimp_cmd assimp ${ZLIB_LIBRARIES} )
 SET_TARGET_PROPERTIES( assimp_cmd PROPERTIES
  OUTPUT_NAME assimp
--- a/tools/assimp_view/CMakeLists.txt
+++ b/tools/assimp_view/CMakeLists.txt
@ -37,7 +37,7 @@
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #
 #----------------------------------------------------------------------
-cmake_minimum_required( VERSION 2.6 )
+cmake_minimum_required( VERSION 3.0 )
 FIND_PACKAGE(DirectX REQUIRED)
@ -90,14 +90,7 @@ IF ( MSVC )
  ADD_DEFINITIONS( -D_CRT_SECURE_NO_WARNINGS )
  # assimp_viewer is ANSI (MBCS) throughout
  REMOVE_DEFINITIONS( -DUNICODE -D_UNICODE )
-ENDIF ( MSVC )
+ENDIF ()
 #
 ADD_CUSTOM_COMMAND(TARGET assimp_viewer
  PRE_BUILD
  COMMAND ${CMAKE_COMMAND} -E copy_if_different $<TARGET_FILE:assimp> $<TARGET_FILE_DIR:assimp_viewer>
  MAIN_DEPENDENCY assimp)
 # Link the executable to the assimp + dx libs.
 TARGET_LINK_LIBRARIES ( assimp_viewer assimp ${DirectX_LIBRARY} ${DirectX_D3DX9_LIBRARY} comctl32.lib winmm.lib )