Merge branch 'master' into coverity_scan

.travis.sh

@@ -11,6 +11,6 @@ else
     && sudo make install \
     && sudo ldconfig \
     && (cd test/unit; ../../bin/unit) \
-    #&& (cd test/regression; chmod 755 run.py; ./run.py; \
-	  #chmod 755 result_checker.py; ./result_checker.py)
+    && (cd test/regression; chmod 755 run.py; ./run.py ../../bin/assimp; \
+	   chmod 755 result_checker.py; ./result_checker.py)
 fi

CMakeLists.txt

@@ -1,28 +1,65 @@
-set(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
+# Open Asset Import Library (assimp)
+# ----------------------------------------------------------------------
+# 
+# Copyright (c) 2006-2016, 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.
+#
+#----------------------------------------------------------------------
+SET(CMAKE_LEGACY_CYGWIN_WIN32 0) # Remove when CMake >= 2.8.4 is required
 cmake_minimum_required( VERSION 2.8 )
 PROJECT( Assimp )
 
-option(BUILD_SHARED_LIBS "Build package with shared libraries." ON)
-if(NOT BUILD_SHARED_LIBS)
-  #set(CMAKE_EXE_LINKER_FLAGS "-static")
-  set(LINK_SEARCH_START_STATIC TRUE)
-endif(NOT BUILD_SHARED_LIBS)
+OPTION(BUILD_SHARED_LIBS "Build package with shared libraries." ON)
+IF(NOT BUILD_SHARED_LIBS)
+  SET(LINK_SEARCH_START_STATIC TRUE)
+ENDIF(NOT BUILD_SHARED_LIBS)
 
 # Define here the needed parameters
-set (ASSIMP_VERSION_MAJOR 3)
-set (ASSIMP_VERSION_MINOR 2)
-set (ASSIMP_VERSION_PATCH 0) # subversion revision?
-set (ASSIMP_VERSION ${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH})
-set (ASSIMP_SOVERSION 3)
-set (PROJECT_VERSION "${ASSIMP_VERSION}")
+SET (ASSIMP_VERSION_MAJOR 3)
+SET (ASSIMP_VERSION_MINOR 2)
+SET (ASSIMP_VERSION_PATCH 0) # subversion revision?
+SET (ASSIMP_VERSION ${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH})
+SET (ASSIMP_SOVERSION 3)
+SET (PROJECT_VERSION "${ASSIMP_VERSION}")
 
-set(ASSIMP_PACKAGE_VERSION "0" CACHE STRING "the package-specific version used for uploading the sources")
+SET(ASSIMP_PACKAGE_VERSION "0" CACHE STRING "the package-specific version used for uploading the sources")
 
 # Needed for openddl_parser config, no use of c++11 at this moment
 add_definitions( -DOPENDDL_NO_USE_CPP11 )
+set_property( GLOBAL PROPERTY CXX_STANDARD 11 )
 
 # Get the current working branch
-execute_process(
+EXECUTE_PROCESS(
   COMMAND git rev-parse --abbrev-ref HEAD
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
   OUTPUT_VARIABLE GIT_BRANCH
@@ -31,7 +68,7 @@ execute_process(
 )
 
 # Get the latest abbreviated commit hash of the working branch
-execute_process(
+EXECUTE_PROCESS(
   COMMAND git log -1 --format=%h
   WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}
   OUTPUT_VARIABLE GIT_COMMIT_HASH
@@ -39,9 +76,9 @@ execute_process(
   ERROR_QUIET
 )
 
-if(NOT GIT_COMMIT_HASH)
-  set(GIT_COMMIT_HASH 0)
-endif(NOT GIT_COMMIT_HASH)
+IF(NOT GIT_COMMIT_HASH)
+  SET(GIT_COMMIT_HASH 0)
+ENDIF(NOT GIT_COMMIT_HASH)
 
 configure_file(
   ${CMAKE_CURRENT_SOURCE_DIR}/revision.h.in
@@ -50,30 +87,34 @@ configure_file(
 
 include_directories(${CMAKE_CURRENT_BINARY_DIR})
 
-option(ASSIMP_OPT_BUILD_PACKAGES "Set to ON to generate CPack configuration files and packaging targets" OFF)
-set(CMAKE_MODULE_PATH       "${CMAKE_CURRENT_SOURCE_DIR}/cmake-modules" )
-set(LIBASSIMP_COMPONENT     "libassimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH}" )
-set(LIBASSIMP-DEV_COMPONENT "libassimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH}-dev" )
-set(CPACK_COMPONENTS_ALL assimp-bin ${LIBASSIMP_COMPONENT} ${LIBASSIMP-DEV_COMPONENT} assimp-dev)
-set(ASSIMP_LIBRARY_SUFFIX "" CACHE STRING "Suffix to append to library names")
+OPTION(ASSIMP_OPT_BUILD_PACKAGES "Set to ON to generate CPack configuration files and packaging targets" OFF)
+SET(CMAKE_MODULE_PATH       "${CMAKE_CURRENT_SOURCE_DIR}/cmake-modules" )
+SET(LIBASSIMP_COMPONENT     "libassimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH}" )
+SET(LIBASSIMP-DEV_COMPONENT "libassimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH}-dev" )
+SET(CPACK_COMPONENTS_ALL assimp-bin ${LIBASSIMP_COMPONENT} ${LIBASSIMP-DEV_COMPONENT} assimp-dev)
+SET(ASSIMP_LIBRARY_SUFFIX "" CACHE STRING "Suffix to append to library names")
 
-option(ASSIMP_ANDROID_JNIIOSYSTEM "Android JNI IOSystem support is active" OFF)
+OPTION(ASSIMP_ANDROID_JNIIOSYSTEM "Android JNI IOSystem support is active" OFF)
 
 # Workaround to be able to deal with compiler bug "Too many sections" with mingw.
-if( CMAKE_COMPILER_IS_MINGW )
+IF( CMAKE_COMPILER_IS_MINGW )
   ADD_DEFINITIONS(-DASSIMP_BUILD_NO_IFC_IMPORTER )
-endif()
+ENDIF()
 
-if((CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) AND NOT CMAKE_COMPILER_IS_MINGW)
-  if (BUILD_SHARED_LIBS AND CMAKE_SIZEOF_VOID_P EQUAL 8) # -fPIC is only required for shared libs on 64 bit
-     set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
-  endif()
+IF((CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) AND NOT CMAKE_COMPILER_IS_MINGW)
+  IF (BUILD_SHARED_LIBS AND CMAKE_SIZEOF_VOID_P EQUAL 8) # -fPIC is only required for shared libs on 64 bit
+     SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fPIC")
+  ENDIF()
   # hide all not-exported symbols
-  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall" )
-elseif(MSVC)
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -std=c++0x" )
+ELSEIF(MSVC)
   # enable multi-core compilation with MSVC
-  add_definitions(/MP)
-endif()
+  add_compile_options(/MP)
+ELSEIF ( "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang" )
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wno-long-long -pedantic -std=c++11" )
+ELSEIF( CMAKE_COMPILER_IS_MINGW )
+	SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wno-long-long -pedantic -std=c++11" )
+ENDIF()
 
 INCLUDE (FindPkgConfig)
 INCLUDE_DIRECTORIES( include )
@@ -111,32 +152,7 @@ IF (NOT TARGET uninstall)
   add_custom_target(uninstall "${CMAKE_COMMAND}" -P "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake")
 ENDIF()
 
-# Globally enable Boost resp. the Boost workaround – it is also needed by the
-# tools which include the Assimp headers.
-option ( ASSIMP_ENABLE_BOOST_WORKAROUND
-  "If a simple implementation of the used Boost functions is used. Slightly reduces functionality, but enables builds without Boost available."
-  ON
-)
-IF ( ASSIMP_ENABLE_BOOST_WORKAROUND )
-  INCLUDE_DIRECTORIES( code/BoostWorkaround )
-  ADD_DEFINITIONS( -DASSIMP_BUILD_BOOST_WORKAROUND )
-  MESSAGE( STATUS "Building a non-boost version of Assimp." )
-ELSE ( ASSIMP_ENABLE_BOOST_WORKAROUND )
-  SET( Boost_DETAILED_FAILURE_MSG ON )
-  IF ( NOT Boost_ADDITIONAL_VERSIONS )
-    SET( Boost_ADDITIONAL_VERSIONS "1.47" "1.47.0" "1.48.0" "1.48" "1.49" "1.49.0" "1.50" "1.50.0" "1.51" "1.51.0" "1.52.0" "1.53.0" "1.54.0" "1.55" "1.55.0" "1.56" "1.56.0" "1.57" "1.57.0" "1.58" "1.58.0" "1.59" "1.59.0")
-  ENDIF ( NOT Boost_ADDITIONAL_VERSIONS )
-  FIND_PACKAGE( Boost )
-  IF ( NOT Boost_FOUND )
-    MESSAGE( FATAL_ERROR
-      "Boost libraries (http://www.boost.org/) not found. "
-      "You can build a non-boost version of Assimp with slightly reduced "
-      "functionality by specifying -DASSIMP_ENABLE_BOOST_WORKAROUND=ON."
-    )
-  ENDIF ( NOT Boost_FOUND )
 
-  INCLUDE_DIRECTORIES( ${Boost_INCLUDE_DIRS} )
-ENDIF ( ASSIMP_ENABLE_BOOST_WORKAROUND )
 
 # cmake configuration files
 configure_file("${CMAKE_CURRENT_SOURCE_DIR}/assimp-config.cmake.in"         "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake" @ONLY IMMEDIATE)
@@ -145,38 +161,38 @@ install(FILES "${CMAKE_CURRENT_BINARY_DIR}/assimp-config.cmake"             "${C
 
 FIND_PACKAGE( DirectX )
 
-option ( ASSIMP_NO_EXPORT
+OPTION ( ASSIMP_NO_EXPORT
   "Disable Assimp's export functionality."
   OFF
 )
 
-if( CMAKE_COMPILER_IS_GNUCXX )
-  set(LIBSTDC++_LIBRARIES -lstdc++)
-endif( CMAKE_COMPILER_IS_GNUCXX )
+IF( CMAKE_COMPILER_IS_GNUCXX )
+  SET(LIBSTDC++_LIBRARIES -lstdc++)
+ENDIF( CMAKE_COMPILER_IS_GNUCXX )
 
 # Search for external dependencies, and build them from source if not found
 # Search for zlib
 find_package(ZLIB)
-if( NOT ZLIB_FOUND )
+IF( NOT ZLIB_FOUND )
   message(STATUS "compiling zlib from souces")
   include(CheckIncludeFile)
   include(CheckTypeSize)
   include(CheckFunctionExists)
   # compile from sources
   add_subdirectory(contrib/zlib)
-  set(ZLIB_FOUND 1)
-  set(ZLIB_LIBRARIES zlibstatic)
-  set(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/contrib/zlib ${CMAKE_CURRENT_BINARY_DIR}/contrib/zlib)
+  SET(ZLIB_FOUND 1)
+  SET(ZLIB_LIBRARIES zlibstatic)
+  SET(ZLIB_INCLUDE_DIR ${CMAKE_CURRENT_SOURCE_DIR}/contrib/zlib ${CMAKE_CURRENT_BINARY_DIR}/contrib/zlib)
 else(NOT ZLIB_FOUND)
   ADD_DEFINITIONS(-DASSIMP_BUILD_NO_OWN_ZLIB)
-  set(ZLIB_LIBRARIES_LINKED -lz)
-endif(NOT ZLIB_FOUND)
+  SET(ZLIB_LIBRARIES_LINKED -lz)
+ENDIF(NOT ZLIB_FOUND)
 INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
 
 # Search for unzip
-if (PKG_CONFIG_FOUND)
+IF (PKG_CONFIG_FOUND)
   PKG_CHECK_MODULES(UNZIP minizip)
-endif (PKG_CONFIG_FOUND)
+ENDIF (PKG_CONFIG_FOUND)
 
 IF ( ASSIMP_NO_EXPORT )
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_EXPORT)
@@ -204,7 +220,7 @@ MARK_AS_ADVANCED ( ASSIMP_BUILD_ARCHITECTURE ASSIMP_BUILD_COMPILER )
 
 
 SET ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER OFF CACHE BOOL
-  "Build the C4D importer, which relies on the non-free Melange SDK." 
+  "Build the C4D importer, which relies on the non-free Melange SDK."
 )
 
 IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
@@ -219,44 +235,47 @@ IF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
     ELSEIF(MSVC90)
       SET(C4D_LIB_POSTFIX "_2008md")
     ELSE()
-      MESSAGE( FATAL_ERROR 
+      MESSAGE( FATAL_ERROR
         "C4D is currently only supported with MSVC 9, 10, 11"
       )
     ENDIF()
-      
+
     IF(CMAKE_CL_64)
       SET(C4D_LIB_ARCH_POSTFIX "_x64")
     ELSE()
       SET(C4D_LIB_ARCH_POSTFIX "")
     ENDIF()
-    
+
     SET(C4D_LIB_BASE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/contrib/Melange/_melange/lib/WIN")
-    
+
     SET(C4D_DEBUG_LIBRARY "${C4D_LIB_BASE_PATH}/debug/_melange_lib${C4D_LIB_ARCH_POSTFIX}${C4D_LIB_POSTFIX}.lib")
     SET(C4D_RELEASE_LIBRARY "${C4D_LIB_BASE_PATH}/release/_melange_lib${C4D_LIB_ARCH_POSTFIX}${C4D_LIB_POSTFIX}.lib")
-    
+
     # winsock and winmm are necessary dependencies of melange (this is undocumented, but true.)
     SET(C4D_EXTRA_LIBRARIES WSock32.lib Winmm.lib)
   ELSE ()
-    MESSAGE( FATAL_ERROR 
+    MESSAGE( FATAL_ERROR
       "C4D is currently only available on Windows with melange SDK installed in contrib/Melange"
     )
   ENDIF ( MSVC )
-else (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
+ELSE (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_C4D_IMPORTER )
 ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 
 
-
 ADD_SUBDIRECTORY( code/ )
 option ( ASSIMP_BUILD_ASSIMP_TOOLS
   "If the supplementary tools for Assimp are built in addition to the library."
   ON
 )
 IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
-  IF ( WIN32 AND DirectX_FOUND )
-    ADD_SUBDIRECTORY( tools/assimp_view/ )
-  ENDIF ( WIN32 AND DirectX_FOUND )
+  IF ( WIN32 )
+    option ( ASSIMP_BUILD_ASSIMP_VIEW "If the Assimp view tool is built. (requires DirectX)" ${DirectX_FOUND} )
+    IF ( ASSIMP_BUILD_ASSIMP_VIEW )
+      ADD_SUBDIRECTORY( tools/assimp_view/ )
+    ENDIF ( ASSIMP_BUILD_ASSIMP_VIEW )
+  ENDIF ( WIN32 )
+  
   ADD_SUBDIRECTORY( tools/assimp_cmd/ )
 ENDIF ( ASSIMP_BUILD_ASSIMP_TOOLS )
 
@@ -272,7 +291,7 @@ IF ( ASSIMP_BUILD_SAMPLES)
   ADD_SUBDIRECTORY( samples/SimpleOpenGL/ )
 ENDIF ( ASSIMP_BUILD_SAMPLES )
 
-option ( ASSIMP_BUILD_TESTS
+OPTION ( ASSIMP_BUILD_TESTS
   "If the test suite for Assimp is built in addition to the library."
   ON
 )
@@ -282,7 +301,7 @@ IF ( ASSIMP_BUILD_TESTS )
 ENDIF ( ASSIMP_BUILD_TESTS )
 
 IF(MSVC)
-  option ( ASSIMP_INSTALL_PDB
+  OPTION ( ASSIMP_INSTALL_PDB
     "Install MSVC debug files."
     ON
   )
@@ -292,72 +311,72 @@ ENDIF(MSVC)
 CONFIGURE_FILE( "${PROJECT_SOURCE_DIR}/assimp.pc.in" "${PROJECT_BINARY_DIR}/assimp.pc" @ONLY )
 INSTALL( FILES "${PROJECT_BINARY_DIR}/assimp.pc" DESTINATION ${ASSIMP_LIB_INSTALL_DIR}/pkgconfig/ COMPONENT ${LIBASSIMP-DEV_COMPONENT})
 
-if(CMAKE_CPACK_COMMAND AND UNIX AND ASSIMP_OPT_BUILD_PACKAGES)
+IF(CMAKE_CPACK_COMMAND AND UNIX AND ASSIMP_OPT_BUILD_PACKAGES)
   # Packing information
-  set(CPACK_PACKAGE_NAME                    "assimp{ASSIMP_VERSION_MAJOR}")
-  set(CPACK_PACKAGE_CONTACT "" CACHE STRING "Package maintainer and PGP signer.")
-  set(CPACK_PACKAGE_VENDOR                  "http://assimp.sourceforge.net/")
-  set(CPACK_PACKAGE_DISPLAY_NAME            "Assimp ${ASSIMP_VERSION}")
-  set(CPACK_PACKAGE_DESCRIPTION_SUMMARY     " - Open Asset Import Library ${ASSIMP_VERSION}")
-  set(CPACK_PACKAGE_VERSION                 "${ASSIMP_VERSION}.${ASSIMP_PACKAGE_VERSION}" )
-  set(CPACK_PACKAGE_VERSION_MAJOR           "${ASSIMP_VERSION_MAJOR}")
-  set(CPACK_PACKAGE_VERSION_MINOR           "${ASSIMP_VERSION_MINOR}")
-  set(CPACK_PACKAGE_VERSION_PATCH           "${ASSIMP_VERSION_PATCH}")
-  set(CPACK_PACKAGE_INSTALL_DIRECTORY       "assimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}")
-  set(CPACK_RESOURCE_FILE_LICENSE           "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
+  SET(CPACK_PACKAGE_NAME                    "assimp{ASSIMP_VERSION_MAJOR}")
+  SET(CPACK_PACKAGE_CONTACT "" CACHE STRING "Package maintainer and PGP signer.")
+  SET(CPACK_PACKAGE_VENDOR                  "https://github.com/assimp")
+  SET(CPACK_PACKAGE_DISPLAY_NAME            "Assimp ${ASSIMP_VERSION}")
+  SET(CPACK_PACKAGE_DESCRIPTION_SUMMARY     " - Open Asset Import Library ${ASSIMP_VERSION}")
+  SET(CPACK_PACKAGE_VERSION                 "${ASSIMP_VERSION}.${ASSIMP_PACKAGE_VERSION}" )
+  SET(CPACK_PACKAGE_VERSION_MAJOR           "${ASSIMP_VERSION_MAJOR}")
+  SET(CPACK_PACKAGE_VERSION_MINOR           "${ASSIMP_VERSION_MINOR}")
+  SET(CPACK_PACKAGE_VERSION_PATCH           "${ASSIMP_VERSION_PATCH}")
+  SET(CPACK_PACKAGE_INSTALL_DIRECTORY       "assimp${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}")
+  SET(CPACK_RESOURCE_FILE_LICENSE           "${CMAKE_CURRENT_SOURCE_DIR}/LICENSE")
 
   string(TOUPPER ${LIBASSIMP_COMPONENT}     "LIBASSIMP_COMPONENT_UPPER")
   string(TOUPPER ${LIBASSIMP-DEV_COMPONENT} "LIBASSIMP-DEV_COMPONENT_UPPER")
 
-  set(CPACK_COMPONENT_ASSIMP-BIN_DISPLAY_NAME                       "tools")
-  set(CPACK_COMPONENT_ASSIMP-BIN_DEPENDS                            "${LIBASSIMP_COMPONENT}" )
-  set(CPACK_COMPONENT_${LIBASSIMP_COMPONENT_UPPER}_DISPLAY_NAME     "libraries")
-  set(CPACK_COMPONENT_${LIBASSIMP-DEV_COMPONENT_UPPER}_DISPLAY_NAME "common headers and installs")
-  set(CPACK_COMPONENT_${LIBASSIMP-DEV_COMPONENT_UPPER}_DEPENDS $    "{LIBASSIMP_COMPONENT}" )
-  set(CPACK_COMPONENT_ASSIMP-DEV_DISPLAY_NAME                       "${CPACK_COMPONENT_${LIBASSIMP-DEV_COMPONENT}_DISPLAY_NAME}" )
-  set(CPACK_COMPONENT_ASSIMP-DEV_DEPENDS                            "${LIBASSIMP-DEV_COMPONENT}" )
-  set(CPACK_DEBIAN_BUILD_DEPENDS debhelper cmake libboost-dev libboost-thread-dev libboost-math-dev zlib1g-dev pkg-config)
+  SET(CPACK_COMPONENT_ASSIMP-BIN_DISPLAY_NAME                       "tools")
+  SET(CPACK_COMPONENT_ASSIMP-BIN_DEPENDS                            "${LIBASSIMP_COMPONENT}" )
+  SET(CPACK_COMPONENT_${LIBASSIMP_COMPONENT_UPPER}_DISPLAY_NAME     "libraries")
+  SET(CPACK_COMPONENT_${LIBASSIMP-DEV_COMPONENT_UPPER}_DISPLAY_NAME "common headers and installs")
+  SET(CPACK_COMPONENT_${LIBASSIMP-DEV_COMPONENT_UPPER}_DEPENDS $    "{LIBASSIMP_COMPONENT}" )
+  SET(CPACK_COMPONENT_ASSIMP-DEV_DISPLAY_NAME                       "${CPACK_COMPONENT_${LIBASSIMP-DEV_COMPONENT}_DISPLAY_NAME}" )
+  SET(CPACK_COMPONENT_ASSIMP-DEV_DEPENDS                            "${LIBASSIMP-DEV_COMPONENT}" )
+  SET(CPACK_DEBIAN_BUILD_DEPENDS debhelper cmake zlib1g-dev pkg-config)
 
   # debian
-  set(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
-  set(CPACK_DEBIAN_CMAKE_OPTIONS    "-DBUILD_ASSIMP_SAMPLES:BOOL=${ASSIMP_BUILD_SAMPLES}")
-  set(CPACK_DEBIAN_PACKAGE_SECTION  "libs" )
-  set(CPACK_DEBIAN_PACKAGE_DEPENDS  "${CPACK_COMPONENTS_ALL}")
-  set(CPACK_DEBIAN_PACKAGE_SUGGESTS)
-  set(CPACK_DEBIAN_PACKAGE_NAME     "assimp")
-  set(CPACK_DEBIAN_PACKAGE_REMOVE_SOURCE_FILES contrib/cppunit-1.12.1 contrib/cppunit_note.txt contrib/zlib workspaces test doc obj samples packaging)
-  set(CPACK_DEBIAN_PACKAGE_SOURCE_COPY svn export --force)
-  set(CPACK_DEBIAN_CHANGELOG)
+  SET(CPACK_DEBIAN_PACKAGE_PRIORITY "optional")
+  SET(CPACK_DEBIAN_CMAKE_OPTIONS    "-DBUILD_ASSIMP_SAMPLES:BOOL=${ASSIMP_BUILD_SAMPLES}")
+  SET(CPACK_DEBIAN_PACKAGE_SECTION  "libs" )
+  SET(CPACK_DEBIAN_PACKAGE_DEPENDS  "${CPACK_COMPONENTS_ALL}")
+  SET(CPACK_DEBIAN_PACKAGE_SUGGESTS)
+  SET(CPACK_DEBIAN_PACKAGE_NAME     "assimp")
+  SET(CPACK_DEBIAN_PACKAGE_REMOVE_SOURCE_FILES contrib/cppunit-1.12.1 contrib/cppunit_note.txt contrib/zlib workspaces test doc obj samples packaging)
+  SET(CPACK_DEBIAN_PACKAGE_SOURCE_COPY svn export --force)
+  SET(CPACK_DEBIAN_CHANGELOG)
   execute_process(COMMAND lsb_release -is
     OUTPUT_VARIABLE _lsb_distribution OUTPUT_STRIP_TRAILING_WHITESPACE
     RESULT_VARIABLE _lsb_release_failed)
-  set(CPACK_DEBIAN_DISTRIBUTION_NAME ${_lsb_distribution} CACHE STRING "Name of the distrubiton")
-  string(TOLOWER ${CPACK_DEBIAN_DISTRIBUTION_NAME} CPACK_DEBIAN_DISTRIBUTION_NAME)
-  if( ${CPACK_DEBIAN_DISTRIBUTION_NAME} STREQUAL "ubuntu" )
-    set(CPACK_DEBIAN_DISTRIBUTION_RELEASES lucid maverick natty oneiric precise CACHE STRING "Release code-names of the distrubiton release")
-  endif()
-  set(DPUT_HOST "" CACHE STRING "PPA repository to upload the debian sources")
+  SET(CPACK_DEBIAN_DISTRIBUTION_NAME ${_lsb_distribution} CACHE STRING "Name of the distrubiton")
+  STRING(TOLOWER ${CPACK_DEBIAN_DISTRIBUTION_NAME} CPACK_DEBIAN_DISTRIBUTION_NAME)
+  IF( ${CPACK_DEBIAN_DISTRIBUTION_NAME} STREQUAL "ubuntu" )
+    SET(CPACK_DEBIAN_DISTRIBUTION_RELEASES lucid maverick natty oneiric precise CACHE STRING "Release code-names of the distrubiton release")
+  ENDIF()
+  SET(DPUT_HOST "" CACHE STRING "PPA repository to upload the debian sources")
   include(CPack)
   include(DebSourcePPA)
-endif()
+ENDIF()
 
 if(WIN32)
 	if (CMAKE_SIZEOF_VOID_P EQUAL 8)
-		set(BIN_DIR "${PROJECT_SOURCE_DIR}/bin64/")
-		set(LIB_DIR "${PROJECT_SOURCE_DIR}/lib64/")
+		SET(BIN_DIR "${PROJECT_SOURCE_DIR}/bin64/")
+		SET(LIB_DIR "${PROJECT_SOURCE_DIR}/lib64/")
 	elseif()
-		set(BIN_DIR "${PROJECT_SOURCE_DIR}/bin32/")
-		set(LIB_DIR "${PROJECT_SOURCE_DIR}/lib32/")
-	endif()
-	
+		SET(BIN_DIR "${PROJECT_SOURCE_DIR}/bin32/")
+		SET(LIB_DIR "${PROJECT_SOURCE_DIR}/lib32/")
+	ENDIF()
+
 	if(MSVC12)
-		set(ASSIMP_MSVC_VERSION "vc120")
-	elseif(MSVC14)	
-		set(ASSIMP_MSVC_VERSION "vc140")
-	endif(MSVC12)
+		SET(ASSIMP_MSVC_VERSION "vc120")
+	elseif(MSVC14)
+		SET(ASSIMP_MSVC_VERSION "vc140")
+	ENDIF(MSVC12)
 
 	if(MSVC12 OR MSVC14)
-		add_custom_target(UpdateAssimpLibsDebugSymbolsAndDLLs COMMENT "Copying Assimp Libraries ..." VERBATIM)	
+		add_custom_target(UpdateAssimpLibsDebugSymbolsAndDLLs COMMENT "Copying Assimp Libraries ..." VERBATIM)
 		add_custom_command(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.dll	${BIN_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.dll VERBATIM)
 		add_custom_command(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.exp	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.exp VERBATIM)
 		add_custom_command(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Release/assimp-${ASSIMP_MSVC_VERSION}-mt.lib	${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mt.lib VERBATIM)
@@ -366,5 +385,5 @@ if(WIN32)
 		add_custom_command(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.ilk VERBATIM)
 		add_custom_command(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.lib		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.lib VERBATIM)
 		add_custom_command(TARGET UpdateAssimpLibsDebugSymbolsAndDLLs COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_BINARY_DIR}/code/Debug/assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb		${LIB_DIR}assimp-${ASSIMP_MSVC_VERSION}-mtd.pdb VERBATIM)
-	endif(MSVC12 OR MSVC14)
-endif (WIN32)
+	ENDIF(MSVC12 OR MSVC14)
+ENDIF (WIN32)

CREDITS

@@ -30,7 +30,7 @@ Ogre Loader, VC2010 fixes and CMake fixes.
 
 - Sebastian Hempel,
 PyAssimp (first version)
-Compile-Bugfixes for mingw, add enviroment for static library support in make.
+Compile-Bugfixes for mingw, add environment for static library support in make.
 
 - Jonathan Pokrass
 Supplied a bugfix concerning the scaling in the md3 loader.
@@ -114,7 +114,7 @@ Contributes a fix for the configure script environment.
 Contributed AssimpDelphi (/port/AssimpDelphi).
 
 - rdb 
-Contributes a bundle of fixes and improvments for the bsp-importer.
+Contributes a bundle of fixes and improvements for the bsp-importer.
 
 - Mick P
 For contributing the De-bone postprocessing step and filing various bug reports.

Readme.md

@@ -60,7 +60,8 @@ __Importers__:
 - Ogre XML
 - Q3D
 - ASSBIN (Assimp custom format)
-- glTF
+- glTF (partial)
+- 3MF
 
 Additionally, some formats are supported by dependency on non-free code or external SDKs (not built by default):
 
@@ -76,7 +77,8 @@ __Exporters__:
 - 3DS
 - JSON (for WebGl, via https://github.com/acgessler/assimp2json)
 - ASSBIN
-- glTF
+- STEP
+- glTF (partial)
 
 ### Building ###
 Take a look into the `INSTALL` file. Our build system is CMake, if you used CMake before there is a good chance you know what to do.
@@ -100,7 +102,7 @@ Open Asset Import Library is implemented in C++. The directory structure is:
 	/tools		Tools (old assimp viewer, command line `assimp`)
 	/samples	A small number of samples to illustrate possible
                         use cases for Assimp
-	/workspaces	Build enviroments for vc,xcode,... (deprecated,
+	/workspaces	Build environments for vc,xcode,... (deprecated,
 			CMake has superseeded all legacy build options!)
 
 
@@ -120,6 +122,10 @@ And we also have an IRC-channel at freenode: #assetimporterlib . You can easily
 Contributions to assimp are highly appreciated. The easiest way to get involved is to submit
 a pull request with your changes against the main repository's `master` branch.
 
+### Donate ###
+If you like assimp, consider buying us a beer (or two):
+[Donate](http://sourceforge.net/donate/index.php?group_id=226462)
+
 ### License ###
 Our license is based on the modified, __3-clause BSD__-License.
 

appveyor.yml

@@ -18,7 +18,7 @@ configuration:
   - 14 2015
   - 12 2013
   #- MinGW
-  - 10 2010 # only works for x86
+  #- 10 2010 # only works for x86
 
 init:
 - if "%platform%" EQU "x64" ( for %%a in (2008 2010 MinGW) do ( if "%Configuration%"=="%%a" (echo "Skipping unsupported configuration" && exit /b 1 ) ) )

assimp-config.cmake.in

@@ -64,7 +64,7 @@ set( ASSIMP_LIBRARIES ${ASSIMP_LIBRARIES}@CMAKE_DEBUG_POSTFIX@)
 # the boost version assimp was compiled with
 set( ASSIMP_Boost_VERSION "@Boost_MAJOR_VERSION@.@Boost_MINOR_VERSION@")
 
-# for compatibility wiht pkg-config
+# for compatibility with pkg-config
 set(ASSIMP_CFLAGS_OTHER "${ASSIMP_CXX_FLAGS}")
 set(ASSIMP_LDFLAGS_OTHER "${ASSIMP_LINK_FLAGS}")
 

code/3DSConverter.cpp

@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/scene.h"
 #include "../include/assimp/DefaultLogger.hpp"
 #include "StringComparison.h"
-#include <boost/scoped_array.hpp>
+#include <memory>
 #include <cctype>
 
 using namespace Assimp;
@@ -359,7 +359,7 @@ void Discreet3DSImporter::ConvertMeshes(aiScene* pcOut)
 
     // we need to split all meshes by their materials
     for (std::vector<D3DS::Mesh>::iterator i =  mScene->mMeshes.begin(); i != mScene->mMeshes.end();++i)    {
-        boost::scoped_array< std::vector<unsigned int> > aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
+        std::unique_ptr< std::vector<unsigned int>[] > aiSplit(new std::vector<unsigned int>[mScene->mMaterials.size()]);
 
         name.length = ASSIMP_itoa10(name.data,num++);
 

code/3DSExporter.cpp

@@ -150,7 +150,7 @@ namespace {
 // Worker function for exporting a scene to 3DS. Prototyped and registered in Exporter.cpp
 void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScene, const ExportProperties* pProperties)
 {
-    boost::shared_ptr<IOStream> outfile (pIOSystem->Open(pFile, "wb"));
+    std::shared_ptr<IOStream> outfile (pIOSystem->Open(pFile, "wb"));
     if(!outfile) {
         throw DeadlyExportError("Could not open output .3ds file: " + std::string(pFile));
     }
@@ -164,7 +164,7 @@ void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScen
     // in |Exporter::ExportFormatEntry|.
     aiScene* scenecopy_tmp;
     SceneCombiner::CopyScene(&scenecopy_tmp,pScene);
-    std::auto_ptr<aiScene> scenecopy(scenecopy_tmp);
+    std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
 
     SplitLargeMeshesProcess_Triangle tri_splitter;
     tri_splitter.SetLimit(0xffff);
@@ -181,7 +181,7 @@ void ExportScene3DS(const char* pFile, IOSystem* pIOSystem, const aiScene* pScen
 } // end of namespace Assimp
 
 // ------------------------------------------------------------------------------------------------
-Discreet3DSExporter:: Discreet3DSExporter(boost::shared_ptr<IOStream> outfile, const aiScene* scene)
+Discreet3DSExporter:: Discreet3DSExporter(std::shared_ptr<IOStream> outfile, const aiScene* scene)
 : scene(scene)
 , writer(outfile)
 {

code/3DSExporter.h

@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_3DSEXPORTER_H_INC
 
 #include <map>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 #include "StreamWriter.h"
 #include "./../include/assimp/material.h"
@@ -64,7 +64,7 @@ namespace Assimp
 class Discreet3DSExporter
 {
 public:
-    Discreet3DSExporter(boost::shared_ptr<IOStream> outfile, const aiScene* pScene);
+    Discreet3DSExporter(std::shared_ptr<IOStream> outfile, const aiScene* pScene);
 
 private:
 

code/3DSLoader.cpp

@@ -197,7 +197,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
         ComputeNormalsWithSmoothingsGroups<D3DS::Face>(*i);
     }
 
-    // Replace all occurences of the default material with a
+    // Replace all occurrences of the default material with a
     // valid material. Generate it if no material containing
     // DEFAULT in its name has been found in the file
     ReplaceDefaultMaterial();

code/ACLoader.cpp

@@ -60,7 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/scene.h"
 #include "../include/assimp/config.h"
 #include "../include/assimp/IOSystem.hpp"
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 
 using namespace Assimp;
 
@@ -708,7 +708,7 @@ aiNode* AC3DImporter::ConvertObjectSection(Object& object,
             // collect all meshes using the same material group.
             if (object.subDiv)  {
                 if (configEvalSubdivision) {
-                    boost::scoped_ptr<Subdivider> div(Subdivider::Create(Subdivider::CATMULL_CLARKE));
+                    std::unique_ptr<Subdivider> div(Subdivider::Create(Subdivider::CATMULL_CLARKE));
                     DefaultLogger::get()->info("AC3D: Evaluating subdivision surface: "+object.name);
 
                     std::vector<aiMesh*> cpy(meshes.size()-oldm,NULL);
@@ -787,7 +787,7 @@ void AC3DImporter::SetupProperties(const Importer* pImp)
 void AC3DImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
 
     // Check whether we can read from the file
     if( file.get() == NULL)
@@ -884,7 +884,7 @@ void AC3DImporter::InternReadFile( const std::string& pFile,
     // copy meshes
     if (meshes.empty())
     {
-        throw DeadlyImportError("An unknown error occured during converting");
+        throw DeadlyImportError("An unknown error occurred during converting");
     }
     pScene->mNumMeshes = (unsigned int)meshes.size();
     pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];

code/ASELoader.cpp

@@ -51,7 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "SkeletonMeshBuilder.h"
 #include "TargetAnimation.h"
 #include "../include/assimp/Importer.hpp"
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/scene.h"
@@ -130,7 +130,7 @@ void ASEImporter::SetupProperties(const Importer* pImp)
 void ASEImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
 
     // Check whether we can read from the file
     if( file.get() == NULL) {

code/ASEParser.h

@@ -43,11 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_ASEFILEHELPER_H_INC
 #define AI_ASEFILEHELPER_H_INC
 
-// STL/CRT headers
-#include <string>
-#include <vector>
-#include <list>
-
 // public ASSIMP headers
 #include "../include/assimp/types.h"
 #include "../include/assimp/mesh.h"
@@ -609,7 +604,7 @@ private:
     //! \param out Output string
     //! \param szName Name of the enclosing element -> used in error
     //! messages.
-    //! \return false if an error occured
+    //! \return false if an error occurred
     bool ParseString(std::string& out,const char* szName);
 
 public:

code/AssbinExporter.cpp

@@ -47,7 +47,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/Exporter.hpp"
 #include "ProcessHelper.h"
 #include "Exceptional.h"
-#include <boost/static_assert.hpp>
 
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
 #   include <zlib.h>
@@ -103,7 +102,7 @@ inline size_t Write<unsigned int>(IOStream * stream, const unsigned int& w)
 template <>
 inline size_t Write<uint16_t>(IOStream * stream, const uint16_t& w)
 {
-    BOOST_STATIC_ASSERT(sizeof(uint16_t)==2);
+    static_assert(sizeof(uint16_t)==2, "sizeof(uint16_t)==2");
     stream->Write(&w,2,1);
     return 2;
 }
@@ -113,7 +112,7 @@ inline size_t Write<uint16_t>(IOStream * stream, const uint16_t& w)
 template <>
 inline size_t Write<float>(IOStream * stream, const float& f)
 {
-    BOOST_STATIC_ASSERT(sizeof(float)==4);
+    static_assert(sizeof(float)==4, "sizeof(float)==4");
     stream->Write(&f,4,1);
     return 4;
 }
@@ -123,7 +122,7 @@ inline size_t Write<float>(IOStream * stream, const float& f)
 template <>
 inline size_t Write<double>(IOStream * stream, const double& f)
 {
-    BOOST_STATIC_ASSERT(sizeof(double)==8);
+    static_assert(sizeof(double)==8, "sizeof(double)==8");
     stream->Write(&f,8,1);
     return 8;
 }
@@ -472,7 +471,7 @@ inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
                         uint32_t tmp = f.mNumIndices;
                         hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
                         for (unsigned int i = 0; i < f.mNumIndices; ++i) {
-                            BOOST_STATIC_ASSERT(AI_MAX_VERTICES <= 0xffffffff);
+                            static_assert(AI_MAX_VERTICES <= 0xffffffff, "AI_MAX_VERTICES <= 0xffffffff");
                             tmp = static_cast<uint32_t>( f.mIndices[i] );
                             hash = SuperFastHash(reinterpret_cast<const char*>(&tmp),sizeof tmp,hash);
                         }
@@ -486,7 +485,7 @@ inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
                 for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
                     const aiFace& f = mesh->mFaces[i];
 
-                    BOOST_STATIC_ASSERT(AI_MAX_FACE_INDICES <= 0xffff);
+                    static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
                     Write<uint16_t>(&chunk,f.mNumIndices);
 
                     for (unsigned int a = 0; a < f.mNumIndices;++a) {

code/AssbinLoader.cpp

@@ -54,7 +54,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/mesh.h"
 #include "../include/assimp/anim.h"
 #include "../include/assimp/scene.h"
-#include <boost/static_assert.hpp>
 
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
 #   include <zlib.h>
@@ -351,7 +350,7 @@ void AssbinImporter::ReadBinaryMesh( IOStream * stream, aiMesh* mesh )
         for (unsigned int i = 0; i < mesh->mNumFaces;++i) {
             aiFace& f = mesh->mFaces[i];
 
-            BOOST_STATIC_ASSERT(AI_MAX_FACE_INDICES <= 0xffff);
+            static_assert(AI_MAX_FACE_INDICES <= 0xffff, "AI_MAX_FACE_INDICES <= 0xffff");
             f.mNumIndices = Read<uint16_t>(stream);
             f.mIndices = new unsigned int[f.mNumIndices];
 

code/Assimp.cpp

@@ -59,8 +59,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // ------------------------------------------------------------------------------------------------
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#   include <boost/thread/thread.hpp>
-#   include <boost/thread/mutex.hpp>
+#   include <thread>
+#   include <mutex>
 #endif
 // ------------------------------------------------------------------------------------------------
 using namespace Assimp;
@@ -103,7 +103,7 @@ namespace Assimp
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
 /** Global mutex to manage the access to the log-stream map */
-static boost::mutex gLogStreamMutex;
+static std::mutex gLogStreamMutex;
 #endif
 
 
@@ -119,7 +119,7 @@ public:
 
     ~LogToCallbackRedirector()  {
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-        boost::mutex::scoped_lock lock(gLogStreamMutex);
+        std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
         // (HACK) Check whether the 'stream.user' pointer points to a
         // custom LogStream allocated by #aiGetPredefinedLogStream.
@@ -321,8 +321,8 @@ ASSIMP_API const aiScene* aiApplyPostProcessing(const aiScene* pScene,
 }
 
 // ------------------------------------------------------------------------------------------------
-ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene, 
-                                                           BaseProcess* process, 
+ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene,
+                                                           BaseProcess* process,
                                                            bool requestValidation ) {
     const aiScene* sc( NULL );
 
@@ -343,7 +343,7 @@ ASSIMP_API const aiScene *aiApplyCustomizedPostProcessing( const aiScene *scene,
     }
 
     ASSIMP_END_EXCEPTION_REGION( const aiScene* );
-    
+
     return sc;
 }
 
@@ -383,7 +383,7 @@ ASSIMP_API void aiAttachLogStream( const aiLogStream* stream )
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-    boost::mutex::scoped_lock lock(gLogStreamMutex);
+    std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
 
     LogStream* lg = new LogToCallbackRedirector(*stream);
@@ -402,7 +402,7 @@ ASSIMP_API aiReturn aiDetachLogStream( const aiLogStream* stream)
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-    boost::mutex::scoped_lock lock(gLogStreamMutex);
+    std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
     // find the log-stream associated with this data
     LogStreamMap::iterator it = gActiveLogStreams.find( *stream);
@@ -427,7 +427,7 @@ ASSIMP_API void aiDetachAllLogStreams(void)
 {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-    boost::mutex::scoped_lock lock(gLogStreamMutex);
+    std::lock_guard<std::mutex> lock(gLogStreamMutex);
 #endif
     Logger *logger( DefaultLogger::get() );
     if ( NULL == logger ) {
@@ -440,7 +440,7 @@ ASSIMP_API void aiDetachAllLogStreams(void)
     }
     gActiveLogStreams.clear();
     DefaultLogger::kill();
-    
+
     ASSIMP_END_EXCEPTION_REGION(void);
 }
 

code/AssxmlExporter.cpp

@@ -65,13 +65,21 @@ namespace Assimp    {
 
 namespace AssxmlExport  {
 
-int ioprintf( IOStream * io, const char * format, ... )
-{
-    char sz[4096];
+// -----------------------------------------------------------------------------------
+static int ioprintf( IOStream * io, const char *format, ... ) {
+	using namespace std;
+    if ( nullptr == io ) {
+        return -1;
+    }
+
+    static const size_t Size = 4096;
+    char sz[ Size ];
+    size_t len( strlen( format ) );
+    ::memset( sz, '\0', Size );
     va_list va;
     va_start( va, format );
-    int nSize = ai_snprintf( sz, 4096, format, va );
-   ai_assert( nSize < 4096 );
+    int nSize = vsnprintf( sz, Size-1, format, va );
+    ai_assert( nSize < Size );
     va_end( va );
 
     io->Write( sz, sizeof(char), nSize );
@@ -81,8 +89,7 @@ int ioprintf( IOStream * io, const char * format, ... )
 
 // -----------------------------------------------------------------------------------
 // Convert a name to standard XML format
-void ConvertName(aiString& out, const aiString& in)
-{
+static void ConvertName(aiString& out, const aiString& in) {
     out.length = 0;
     for (unsigned int i = 0; i < in.length; ++i)  {
         switch (in.data[i]) {
@@ -105,8 +112,7 @@ void ConvertName(aiString& out, const aiString& in)
 
 // -----------------------------------------------------------------------------------
 // Write a single node as text dump
-void WriteNode(const aiNode* node, IOStream * io, unsigned int depth)
-{
+static void WriteNode(const aiNode* node, IOStream * io, unsigned int depth) {
     char prefix[512];
     for (unsigned int i = 0; i < depth;++i)
         prefix[i] = '\t';
@@ -156,47 +162,46 @@ void WriteNode(const aiNode* node, IOStream * io, unsigned int depth)
 // Some chuncks of text will need to be encoded for XML
 // http://stackoverflow.com/questions/5665231/most-efficient-way-to-escape-xml-html-in-c-string#5665377
 static std::string encodeXML(const std::string& data) {
-        std::string buffer;
-        buffer.reserve(data.size());
-        for(size_t pos = 0; pos != data.size(); ++pos) {
-                switch(data[pos]) {
-                        case '&':  buffer.append("&amp;");              break;
-                        case '\"': buffer.append("&quot;");             break;
-                        case '\'': buffer.append("&apos;");             break;
-                        case '<':  buffer.append("&lt;");                   break;
-                        case '>':  buffer.append("&gt;");                   break;
-                        default:   buffer.append(&data[pos], 1);    break;
-                }
-        }
-        return buffer;
+    std::string buffer;
+    buffer.reserve(data.size());
+    for(size_t pos = 0; pos != data.size(); ++pos) {
+            switch(data[pos]) {
+                    case '&':  buffer.append("&amp;");              break;
+                    case '\"': buffer.append("&quot;");             break;
+                    case '\'': buffer.append("&apos;");             break;
+                    case '<':  buffer.append("&lt;");                   break;
+                    case '>':  buffer.append("&gt;");                   break;
+                    default:   buffer.append(&data[pos], 1);    break;
+            }
+    }
+    return buffer;
 }
 
-
-
 // -----------------------------------------------------------------------------------
 // Write a text model dump
-void WriteDump(const aiScene* scene, IOStream* io, bool shortened)
-{
-    time_t tt = ::time(NULL);
-    tm* p     = ::gmtime(&tt);
-
-    aiString name;
+static 
+void WriteDump(const aiScene* scene, IOStream* io, bool shortened) {
+    time_t tt = ::time( NULL );
+    tm* p     = ::gmtime( &tt );
+    ai_assert( nullptr != p );
 
     // write header
-    ioprintf(io,
+    std::string header(
         "<?xml version=\"1.0\" encoding=\"utf-8\"?>\n"
         "<ASSIMP format_id=\"1\">\n\n"
-
         "<!-- XML Model dump produced by assimp dump\n"
         "  Library version: %i.%i.%i\n"
         "  %s\n"
         "-->"
         " \n\n"
-        "<Scene flags=\"%i\" postprocessing=\"%i\">\n",
+        "<Scene flags=\"%d\" postprocessing=\"%i\">\n"
+    );
 
-        aiGetVersionMajor(),aiGetVersionMinor(),aiGetVersionRevision(),asctime(p),
-        scene->mFlags,
-        0 /*globalImporter->GetEffectivePostProcessing()*/);
+    const unsigned int majorVersion( aiGetVersionMajor() );
+    const unsigned int minorVersion( aiGetVersionMinor() );
+    const unsigned int rev( aiGetVersionRevision() );
+    const char *curtime( asctime( p ) );
+    ioprintf( io, header.c_str(), majorVersion, minorVersion, rev, curtime, scene->mFlags, 0 );
 
     // write the node graph
     WriteNode(scene->mRootNode, io, 0);
@@ -266,6 +271,7 @@ void WriteDump(const aiScene* scene, IOStream* io, bool shortened)
         ioprintf(io,"\t</Light>\n");
     }
 #endif
+    aiString name;
 
     // write textures
     if (scene->mNumTextures) {
@@ -301,9 +307,10 @@ void WriteDump(const aiScene* scene, IOStream* io, bool shortened)
                         unsigned int r = tx->r,g=tx->g,b=tx->b,a=tx->a;
                         ioprintf(io,"\t\t\t%2x %2x %2x %2x",r,g,b,a);
 
-                        // group by four for readibility
-                        if (0 == (x+y*tex->mWidth) % 4)
-                            ioprintf(io,"\n");
+                        // group by four for readability
+                        if ( 0 == ( x + y*tex->mWidth ) % 4 ) {
+                            ioprintf( io, "\n" );
+                        }
                     }
                 }
             }

code/B3DImporter.cpp

@@ -7,8 +7,8 @@ Copyright (c) 2006-2016, 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 
+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
@@ -25,16 +25,16 @@ conditions are met:
   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 
+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 
+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 
+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 
+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.
 ---------------------------------------------------------------------------
 */
@@ -51,7 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "TextureTransform.h"
 #include "ConvertToLHProcess.h"
 #include "StringUtils.h"
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/anim.h"
 #include "../include/assimp/scene.h"
@@ -71,11 +71,11 @@ static const aiImporterDesc desc = {
     0,
     0,
     0,
-    "b3d" 
+    "b3d"
 };
 
 // (fixme, Aramis) quick workaround to get rid of all those signed to unsigned warnings
-#ifdef _MSC_VER 
+#ifdef _MSC_VER
 #	pragma warning (disable: 4018)
 #endif
 
@@ -114,7 +114,7 @@ void B3DImporter::InternReadFile( const std::string& pFile, aiScene* pScene, IOS
     cout<<"Hello world from the B3DImporter!"<<endl;
 #endif
 
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
 
     // Check whether we can read from the file
     if( file.get() == NULL)
@@ -280,12 +280,12 @@ void B3DImporter::ReadBRUS(){
 
         aiMaterial *mat=new aiMaterial;
         _materials.push_back( mat );
-        
+
         // Name
         aiString ainame( name );
         mat->AddProperty( &ainame,AI_MATKEY_NAME );
-        
-        // Diffuse color 
+
+        // Diffuse color
         mat->AddProperty( &color,1,AI_MATKEY_COLOR_DIFFUSE );
 
         // Opacity
@@ -294,16 +294,16 @@ void B3DImporter::ReadBRUS(){
         // Specular color
         aiColor3D speccolor( shiny,shiny,shiny );
         mat->AddProperty( &speccolor,1,AI_MATKEY_COLOR_SPECULAR );
-        
+
         // Specular power
         float specpow=shiny*128;
         mat->AddProperty( &specpow,1,AI_MATKEY_SHININESS );
-        
+
         // Double sided
         if( fx & 0x10 ){
-            int i=1; 
+            int i=1;
             mat->AddProperty( &i,1,AI_MATKEY_TWOSIDED );
-        } 		
+        }
 
         //Textures
         for( int i=0;i<n_texs;++i ){
@@ -569,7 +569,7 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
     string t=ReadChunk();
     if( t=="BB3D" ){
         int version=ReadInt();
-        
+
         if (!DefaultLogger::isNullLogger()) {
             char dmp[128];
             ai_snprintf(dmp, 128, "B3D file format version: %i",version);
@@ -669,7 +669,7 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
     }
     scene->mNumMaterials=_materials.size();
     scene->mMaterials=to_array( _materials );
-    
+
     //meshes
     scene->mNumMeshes=_meshes.size();
     scene->mMeshes=to_array( _meshes );

code/BVHLoader.cpp

@@ -47,12 +47,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "fast_atof.h"
 #include "SkeletonMeshBuilder.h"
 #include "../include/assimp/Importer.hpp"
-#include <boost/scoped_ptr.hpp>
-#include <boost/format.hpp>
+#include <memory>
+#include "TinyFormatter.h"
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/scene.h"
 
 using namespace Assimp;
+using namespace Assimp::Formatter;
 
 static const aiImporterDesc desc = {
     "BVH Importer (MoCap)",
@@ -118,7 +119,7 @@ void BVHLoader::InternReadFile( const std::string& pFile, aiScene* pScene, IOSys
     mFileName = pFile;
 
     // read file into memory
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
     if( file.get() == NULL)
         throw DeadlyImportError( "Failed to open file " + pFile + ".");
 
@@ -179,12 +180,12 @@ aiNode* BVHLoader::ReadNode()
     // first token is name
     std::string nodeName = GetNextToken();
     if( nodeName.empty() || nodeName == "{")
-        ThrowException( boost::str( boost::format( "Expected node name, but found \"%s\".") % nodeName));
+        ThrowException( format() << "Expected node name, but found \"" << nodeName << "\"." );
 
     // then an opening brace should follow
     std::string openBrace = GetNextToken();
     if( openBrace != "{")
-        ThrowException( boost::str( boost::format( "Expected opening brace \"{\", but found \"%s\".") % openBrace));
+        ThrowException( format() << "Expected opening brace \"{\", but found \"" << openBrace << "\"." );
 
     // Create a node
     aiNode* node = new aiNode( nodeName);
@@ -216,7 +217,7 @@ aiNode* BVHLoader::ReadNode()
             // The real symbol is "End Site". Second part comes in a separate token
             std::string siteToken = GetNextToken();
             if( siteToken != "Site")
-                ThrowException( boost::str( boost::format( "Expected \"End Site\" keyword, but found \"%s %s\".") % token % siteToken));
+                ThrowException( format() << "Expected \"End Site\" keyword, but found \"" << token << " " << siteToken << "\"." );
 
             aiNode* child = ReadEndSite( nodeName);
             child->mParent = node;
@@ -229,7 +230,7 @@ aiNode* BVHLoader::ReadNode()
         } else
         {
             // everything else is a parse error
-            ThrowException( boost::str( boost::format( "Unknown keyword \"%s\".") % token));
+            ThrowException( format() << "Unknown keyword \"" << token << "\"." );
         }
     }
 
@@ -252,7 +253,7 @@ aiNode* BVHLoader::ReadEndSite( const std::string& pParentName)
     // check opening brace
     std::string openBrace = GetNextToken();
     if( openBrace != "{")
-        ThrowException( boost::str( boost::format( "Expected opening brace \"{\", but found \"%s\".") % openBrace));
+        ThrowException( format() << "Expected opening brace \"{\", but found \"" << openBrace << "\".");
 
     // Create a node
     aiNode* node = new aiNode( "EndSite_" + pParentName);
@@ -274,7 +275,7 @@ aiNode* BVHLoader::ReadEndSite( const std::string& pParentName)
         } else
         {
             // everything else is a parse error
-            ThrowException( boost::str( boost::format( "Unknown keyword \"%s\".") % token));
+            ThrowException( format() << "Unknown keyword \"" << token << "\"." );
         }
     }
 
@@ -321,7 +322,7 @@ void BVHLoader::ReadNodeChannels( BVHLoader::Node& pNode)
         else if( channelToken == "Zrotation")
             pNode.mChannels.push_back( Channel_RotationZ);
         else
-            ThrowException( boost::str( boost::format( "Invalid channel specifier \"%s\".") % channelToken));
+            ThrowException( format() << "Invalid channel specifier \"" << channelToken << "\"." );
     }
 }
 
@@ -332,7 +333,7 @@ void BVHLoader::ReadMotion( aiScene* /*pScene*/)
     // Read number of frames
     std::string tokenFrames = GetNextToken();
     if( tokenFrames != "Frames:")
-        ThrowException( boost::str( boost::format( "Expected frame count \"Frames:\", but found \"%s\".") % tokenFrames));
+        ThrowException( format() << "Expected frame count \"Frames:\", but found \"" << tokenFrames << "\".");
 
     float numFramesFloat = GetNextTokenAsFloat();
     mAnimNumFrames = (unsigned int) numFramesFloat;
@@ -341,7 +342,7 @@ void BVHLoader::ReadMotion( aiScene* /*pScene*/)
     std::string tokenDuration1 = GetNextToken();
     std::string tokenDuration2 = GetNextToken();
     if( tokenDuration1 != "Frame" || tokenDuration2 != "Time:")
-        ThrowException( boost::str( boost::format( "Expected frame duration \"Frame Time:\", but found \"%s %s\".") % tokenDuration1 % tokenDuration2));
+        ThrowException( format() << "Expected frame duration \"Frame Time:\", but found \"" << tokenDuration1 << " " << tokenDuration2 << "\"." );
 
     mAnimTickDuration = GetNextTokenAsFloat();
 
@@ -368,7 +369,7 @@ void BVHLoader::ReadMotion( aiScene* /*pScene*/)
 // Retrieves the next token
 std::string BVHLoader::GetNextToken()
 {
-    // skip any preceeding whitespace
+    // skip any preceding whitespace
     while( mReader != mBuffer.end())
     {
         if( !isspace( *mReader))
@@ -414,7 +415,7 @@ float BVHLoader::GetNextTokenAsFloat()
     ctoken = fast_atoreal_move<float>( ctoken, result);
 
     if( ctoken != token.c_str() + token.length())
-        ThrowException( boost::str( boost::format( "Expected a floating point number, but found \"%s\".") % token));
+        ThrowException( format() << "Expected a floating point number, but found \"" << token << "\"." );
 
     return result;
 }
@@ -423,7 +424,7 @@ float BVHLoader::GetNextTokenAsFloat()
 // Aborts the file reading with an exception
 AI_WONT_RETURN void BVHLoader::ThrowException( const std::string& pError)
 {
-    throw DeadlyImportError( boost::str( boost::format( "%s:%d - %s") % mFileName % mLine % pError));
+    throw DeadlyImportError( format() << mFileName << ":" << mLine << " - " << pError);
 }
 
 // ------------------------------------------------------------------------------------------------

code/BaseImporter.cpp

@@ -52,8 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "../include/assimp/postprocess.h"
 #include <ios>
 #include <list>
-#include <boost/scoped_ptr.hpp>
-#include <boost/scoped_array.hpp>
+#include <memory>
 #include <sstream>
 #include <cctype>
 
@@ -149,10 +148,10 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions)
     if (!pIOHandler)
         return false;
 
-    boost::scoped_ptr<IOStream> pStream (pIOHandler->Open(pFile));
+    std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
     if (pStream.get() ) {
         // read 200 characters from the file
-        boost::scoped_array<char> _buffer (new char[searchBytes+1 /* for the '\0' */]);
+        std::unique_ptr<char[]> _buffer (new char[searchBytes+1 /* for the '\0' */]);
         char* buffer = _buffer.get();
         if( NULL == buffer ) {
             return false;
@@ -256,7 +255,7 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions)
         const uint32_t* magic_u32;
     };
     magic = reinterpret_cast<const char*>(_magic);
-    boost::scoped_ptr<IOStream> pStream (pIOHandler->Open(pFile));
+    std::unique_ptr<IOStream> pStream (pIOHandler->Open(pFile));
     if (pStream.get() ) {
 
         // skip to offset
@@ -336,7 +335,7 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
     // UTF 32 BE with BOM
     if(*((uint32_t*)&data.front()) == 0xFFFE0000) {
 
-        // swap the endianess ..
+        // swap the endianness ..
         for(uint32_t* p = (uint32_t*)&data.front(), *end = (uint32_t*)&data.back(); p <= end; ++p) {
             AI_SWAP4P(p);
         }
@@ -367,7 +366,7 @@ void BaseImporter::ConvertToUTF8(std::vector<char>& data)
     // UTF 16 BE with BOM
     if(*((uint16_t*)&data.front()) == 0xFFFE) {
 
-        // swap the endianess ..
+        // swap the endianness ..
         for(uint16_t* p = (uint16_t*)&data.front(), *end = (uint16_t*)&data.back(); p <= end; ++p) {
             ByteSwap::Swap2(p);
         }
@@ -534,7 +533,7 @@ BatchLoader::~BatchLoader()
 
         delete (*it).scene;
     }
-    data->pImporter->SetIOHandler(NULL); /* get pointer back into our posession */
+    data->pImporter->SetIOHandler(NULL); /* get pointer back into our possession */
     delete data->pImporter;
     delete data;
 }

code/BaseImporter.h

@@ -176,8 +176,8 @@ public:
         );
 
     // -------------------------------------------------------------------
-    /** Returns the error description of the last error that occured.
-     * @return A description of the last error that occured. An empty
+    /** Returns the error description of the last error that occurred.
+     * @return A description of the last error that occurred. An empty
      * string if there was no error.
      */
     const std::string& GetErrorText() const {
@@ -347,7 +347,7 @@ public: // static utilities
     static void ConvertUTF8toISO8859_1(
         std::string& data);
 
-	enum TextFileMode { ALLOW_EMPTY, FORBID_EMPTY };
+    enum TextFileMode { ALLOW_EMPTY, FORBID_EMPTY };
 
     // -------------------------------------------------------------------
     /** Utility for text file loaders which copies the contents of the
@@ -375,7 +375,7 @@ public: // static utilities
         T*& out,
         unsigned int& outLength)
     {
-        outLength = vec.size();
+        outLength = unsigned(vec.size());
         if (outLength) {
             out = new T[outLength];
             std::swap_ranges(vec.begin(), vec.end(), out);

code/BlenderDNA.cpp

@@ -48,13 +48,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderDNA.h"
 #include "StreamReader.h"
 #include "fast_atof.h"
-#include <boost/foreach.hpp>
 
 using namespace Assimp;
 using namespace Assimp::Blender;
 using namespace Assimp::Formatter;
 
-#define for_each BOOST_FOREACH
 bool match4(StreamReaderAny& stream, const char* string) {
     char tmp[] = {
         (stream).GetI1(),
@@ -86,7 +84,7 @@ void DNAParser :: Parse ()
     }
 
     std::vector<std::string> names (stream.GetI4());
-    for_each(std::string& s, names) {
+    for(std::string& s : names) {
         while (char c = stream.GetI1()) {
             s += c;
         }
@@ -99,7 +97,7 @@ void DNAParser :: Parse ()
     }
 
     std::vector<Type> types (stream.GetI4());
-    for_each(Type& s, types) {
+    for(Type& s : types) {
         while (char c = stream.GetI1()) {
             s.name += c;
         }
@@ -111,7 +109,7 @@ void DNAParser :: Parse ()
         throw DeadlyImportError("BlenderDNA: Expected TLEN field");
     }
 
-    for_each(Type& s, types) {
+    for(Type& s : types) {
         s.size = stream.GetI2();
     }
 
@@ -238,13 +236,15 @@ void DNA :: DumpToFile()
     f << "Field format: type name offset size" << "\n";
     f << "Structure format: name size" << "\n";
 
-    for_each(const Structure& s, structures) {
+    for(const Structure& s : structures) {
         f << s.name << " " << s.size << "\n\n";
-        for_each(const Field& ff, s.fields) {
-            f << "\t" << ff.type << " " << ff.name << " " << ff.offset << " " << ff.size << std::endl;
+        for(const Field& ff : s.fields) {
+            f << "\t" << ff.type << " " << ff.name << " " << ff.offset << " " << ff.size << "\n";
         }
-        f << std::endl;
+        f << "\n";
     }
+    f << std::flush;
+
     DefaultLogger::get()->info("BlenderDNA: Dumped dna to dna.txt");
 }
 #endif
@@ -270,17 +270,17 @@ void DNA :: DumpToFile()
 }
 
 // ------------------------------------------------------------------------------------------------
-boost::shared_ptr< ElemBase > DNA :: ConvertBlobToStructure(
+std::shared_ptr< ElemBase > DNA :: ConvertBlobToStructure(
     const Structure& structure,
     const FileDatabase& db
 ) const
 {
     std::map<std::string, FactoryPair >::const_iterator it = converters.find(structure.name);
     if (it == converters.end()) {
-        return boost::shared_ptr< ElemBase >();
+        return std::shared_ptr< ElemBase >();
     }
 
-    boost::shared_ptr< ElemBase > ret = (structure.*((*it).second.first))();
+    std::shared_ptr< ElemBase > ret = (structure.*((*it).second.first))();
     (structure.*((*it).second.second))(ret,db);
 
     return ret;

code/BlenderDNA.h

@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "StreamReader.h"
 #include "../include/assimp/DefaultLogger.hpp"
 #include <stdint.h>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 
 // enable verbose log output. really verbose, so be careful.
@@ -97,7 +97,7 @@ struct ElemBase
      * string points is the `c_str` of the `name` attribute of the
      * corresponding `Structure`, that is, it is only valid as long
      * as the DNA is not modified. The dna_type is only set if the
-     * data type is not static, i.e. a boost::shared_ptr<ElemBase>
+     * data type is not static, i.e. a std::shared_ptr<ElemBase>
      * in the scene description would have its type resolved
      * at runtime, so this member is always set. */
     const char* dna_type;
@@ -127,7 +127,7 @@ struct FileOffset
 
 // -------------------------------------------------------------------------------
 /** Dummy derivate of std::vector to be able to use it in templates simultaenously
- *  with boost::shared_ptr, which takes only one template argument
+ *  with std::shared_ptr, which takes only one template argument
  *  while std::vector takes three. Also we need to provide some special member
  *  functions of shared_ptr */
 // -------------------------------------------------------------------------------
@@ -209,7 +209,7 @@ class Structure
 public:
 
     Structure()
-        :   cache_idx(-1)
+        :   cache_idx(static_cast<size_t>(-1) )
     {}
 
 public:
@@ -260,11 +260,11 @@ public:
     // --------------------------------------------------------
     // generic converter
     template <typename T>
-    void Convert(boost::shared_ptr<ElemBase> in,const FileDatabase& db) const;
+    void Convert(std::shared_ptr<ElemBase> in,const FileDatabase& db) const;
 
     // --------------------------------------------------------
     // generic allocator
-    template <typename T> boost::shared_ptr<ElemBase> Allocate() const;
+    template <typename T> std::shared_ptr<ElemBase> Allocate() const;
 
 
 
@@ -282,7 +282,7 @@ public:
 
     // --------------------------------------------------------
     // field parsing for pointer or dynamic array types
-    // (boost::shared_ptr or boost::shared_array)
+    // (std::shared_ptr)
     // The return value indicates whether the data was already cached.
     template <int error_policy, template <typename> class TOUT, typename T>
     bool ReadFieldPtr(TOUT<T>& out, const char* name,
@@ -291,7 +291,7 @@ public:
 
     // --------------------------------------------------------
     // field parsing for static arrays of pointer or dynamic
-    // array types (boost::shared_ptr[] or boost::shared_array[])
+    // array types (std::shared_ptr[])
     // The return value indicates whether the data was already cached.
     template <int error_policy, template <typename> class TOUT, typename T, size_t N>
     bool ReadFieldPtr(TOUT<T> (&out)[N], const char* name,
@@ -318,7 +318,7 @@ private:
         const FileDatabase& db, const Field& f, bool) const;
 
     // --------------------------------------------------------
-    bool ResolvePointer( boost::shared_ptr< FileOffset >& out, const Pointer & ptrval,
+    bool ResolvePointer( std::shared_ptr< FileOffset >& out, const Pointer & ptrval,
         const FileDatabase& db, const Field& f, bool) const;
 
     // --------------------------------------------------------
@@ -329,8 +329,8 @@ private:
 private:
 
     // ------------------------------------------------------------------------------
-    template <typename T> T* _allocate(boost::shared_ptr<T>& out, size_t& s) const {
-        out = boost::shared_ptr<T>(new T());
+    template <typename T> T* _allocate(std::shared_ptr<T>& out, size_t& s) const {
+        out = std::shared_ptr<T>(new T());
         s = 1;
         return out.get();
     }
@@ -394,7 +394,7 @@ template <> struct Structure :: _defaultInitializer<ErrorPolicy_Fail> {
 };
 
 // -------------------------------------------------------------------------------------------------------
-template <> inline bool Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::shared_ptr<ElemBase>& out,
+template <> inline bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(std::shared_ptr<ElemBase>& out,
     const Pointer & ptrval,
     const FileDatabase& db,
     const Field& f,
@@ -413,11 +413,11 @@ class DNA
 public:
 
     typedef void (Structure::*ConvertProcPtr) (
-        boost::shared_ptr<ElemBase> in,
+        std::shared_ptr<ElemBase> in,
         const FileDatabase&
     ) const;
 
-    typedef boost::shared_ptr<ElemBase> (
+    typedef std::shared_ptr<ElemBase> (
         Structure::*AllocProcPtr) () const;
 
     typedef std::pair< AllocProcPtr, ConvertProcPtr > FactoryPair;
@@ -464,7 +464,7 @@ public:
      *  @param structure Destination structure definition
      *  @param db File database.
      *  @return A null pointer if no appropriate converter is available.*/
-    boost::shared_ptr< ElemBase > ConvertBlobToStructure(
+    std::shared_ptr< ElemBase > ConvertBlobToStructure(
         const Structure& structure,
         const FileDatabase& db
         ) const;
@@ -724,7 +724,7 @@ public:
     bool little;
 
     DNA dna;
-    boost::shared_ptr< StreamReaderAny > reader;
+    std::shared_ptr< StreamReaderAny > reader;
     vector< FileBlockHead > entries;
 
 public:
@@ -738,7 +738,7 @@ public:
     // arrays of objects are never cached because we can't easily
     // ensure their proper destruction.
     template <typename T>
-    ObjectCache<boost::shared_ptr>& cache(boost::shared_ptr<T>& /*in*/) const {
+    ObjectCache<std::shared_ptr>& cache(std::shared_ptr<T>& /*in*/) const {
         return _cache;
     }
 
@@ -755,7 +755,7 @@ private:
 #endif
 
     mutable ObjectCache<vector> _cacheArrays;
-    mutable ObjectCache<boost::shared_ptr> _cache;
+    mutable ObjectCache<std::shared_ptr> _cache;
 
     mutable size_t next_cache_idx;
 };

code/BlenderDNA.inl

@@ -5,8 +5,8 @@ Open Asset Import Library (assimp)
 Copyright (c) 2006-2016, 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 
+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
@@ -23,29 +23,29 @@ following conditions are met:
   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 
+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 
+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 
+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 
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 ----------------------------------------------------------------------
 */
 
 /** @file  BlenderDNA.inl
- *  @brief Blender `DNA` (file format specification embedded in 
+ *  @brief Blender `DNA` (file format specification embedded in
  *    blend file itself) loader.
  */
 #ifndef INCLUDED_AI_BLEND_DNA_INL
 #define INCLUDED_AI_BLEND_DNA_INL
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 namespace Assimp {
     namespace Blender {
@@ -71,7 +71,7 @@ const Field* Structure :: Get (const std::string& ss) const
 }
 
 //--------------------------------------------------------------------------------
-const Field& Structure :: operator [] (const size_t i) const 
+const Field& Structure :: operator [] (const size_t i) const
 {
     if (i >= fields.size()) {
         throw Error((Formatter::format(),
@@ -83,15 +83,15 @@ const Field& Structure :: operator [] (const size_t i) const
 }
 
 //--------------------------------------------------------------------------------
-template <typename T> boost::shared_ptr<ElemBase> Structure :: Allocate() const 
+template <typename T> std::shared_ptr<ElemBase> Structure :: Allocate() const
 {
-    return boost::shared_ptr<T>(new T()); 
+    return std::shared_ptr<T>(new T());
 }
 
 //--------------------------------------------------------------------------------
 template <typename T> void Structure :: Convert(
-    boost::shared_ptr<ElemBase> in,
-    const FileDatabase& db) const 
+    std::shared_ptr<ElemBase> in,
+    const FileDatabase& db) const
 {
     Convert<T> (*static_cast<T*> ( in.get() ),db);
 }
@@ -226,7 +226,7 @@ bool Structure :: ReadFieldPtr(TOUT<T>& out, const char* name, const FileDatabas
 
 //--------------------------------------------------------------------------------
 template <int error_policy, template <typename> class TOUT, typename T, size_t N>
-bool Structure :: ReadFieldPtr(TOUT<T> (&out)[N], const char* name, 
+bool Structure :: ReadFieldPtr(TOUT<T> (&out)[N], const char* name,
     const FileDatabase& db) const
 {
     // XXX see if we can reduce this to call to the 'normal' ReadFieldPtr
@@ -306,12 +306,12 @@ void Structure :: ReadField(T& out, const char* name, const FileDatabase& db) co
 
 //--------------------------------------------------------------------------------
 template <template <typename> class TOUT, typename T>
-bool Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const FileDatabase& db, 
-    const Field& f, 
-    bool non_recursive /*= false*/) const 
+bool Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const FileDatabase& db,
+    const Field& f,
+    bool non_recursive /*= false*/) const
 {
     out.reset(); // ensure null pointers work
-    if (!ptrval.val) { 
+    if (!ptrval.val) {
         return false;
     }
     const Structure& s = db.dna[f.type];
@@ -328,7 +328,7 @@ bool Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const Fil
     }
 
     // try to retrieve the object from the cache
-    db.cache(out).get(s,out,ptrval); 
+    db.cache(out).get(s,out,ptrval);
     if (out) {
         return true;
     }
@@ -340,11 +340,11 @@ bool Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const Fil
     // I really ought to improve StreamReader to work with 64 bit indices exclusively.
 
     // continue conversion after allocating the required storage
-    size_t num = block->size / ss.size; 
+    size_t num = block->size / ss.size;
     T* o = _allocate(out,num);
 
     // cache the object before we convert it to avoid cyclic recursion.
-    db.cache(out).set(s,out,ptrval); 
+    db.cache(out).set(s,out,ptrval);
 
     // if the non_recursive flag is set, we don't do anything but leave
     // the cursor at the correct position to resolve the object.
@@ -366,45 +366,45 @@ bool Structure :: ResolvePointer(TOUT<T>& out, const Pointer & ptrval, const Fil
 
 
 //--------------------------------------------------------------------------------
-inline bool Structure :: ResolvePointer( boost::shared_ptr< FileOffset >& out, const Pointer & ptrval, 
-    const FileDatabase& db, 
+inline bool Structure :: ResolvePointer( std::shared_ptr< FileOffset >& out, const Pointer & ptrval,
+    const FileDatabase& db,
     const Field&,
     bool) const
 {
     // Currently used exclusively by PackedFile::data to represent
-    // a simple offset into the mapped BLEND file. 
+    // a simple offset into the mapped BLEND file.
     out.reset();
-    if (!ptrval.val) { 
+    if (!ptrval.val) {
         return false;
     }
 
     // find the file block the pointer is pointing to
     const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
 
-    out =  boost::shared_ptr< FileOffset > (new FileOffset());
+    out =  std::shared_ptr< FileOffset > (new FileOffset());
     out->val = block->start+ static_cast<size_t>((ptrval.val - block->address.val) );
     return false;
 }
 
 //--------------------------------------------------------------------------------
 template <template <typename> class TOUT, typename T>
-bool Structure :: ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval, 
-    const FileDatabase& db, 
+bool Structure :: ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval,
+    const FileDatabase& db,
     const Field& f,
-    bool) const 
+    bool) const
 {
     // This is a function overload, not a template specialization. According to
     // the partial ordering rules, it should be selected by the compiler
     // for array-of-pointer inputs, i.e. Object::mats.
 
     out.reset();
-    if (!ptrval.val) { 
+    if (!ptrval.val) {
         return false;
     }
 
     // find the file block the pointer is pointing to
     const FileBlockHead* block = LocateFileBlockForAddress(ptrval,db);
-    const size_t num = block->size / (db.i64bit?8:4); 
+    const size_t num = block->size / (db.i64bit?8:4);
 
     // keep the old stream position
     const StreamReaderAny::pos pold = db.reader->GetCurrentPos();
@@ -418,7 +418,7 @@ bool Structure :: ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval,
         Convert(val,db);
 
         // and resolve the pointees
-        res = ResolvePointer(out[i],val,db,f) && res; 
+        res = ResolvePointer(out[i],val,db,f) && res;
     }
 
     db.reader->SetCurrentPos(pold);
@@ -426,18 +426,18 @@ bool Structure :: ResolvePointer(vector< TOUT<T> >& out, const Pointer & ptrval,
 }
 
 //--------------------------------------------------------------------------------
-template <> bool Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::shared_ptr<ElemBase>& out, 
-    const Pointer & ptrval, 
-    const FileDatabase& db, 
+template <> bool Structure :: ResolvePointer<std::shared_ptr,ElemBase>(std::shared_ptr<ElemBase>& out,
+    const Pointer & ptrval,
+    const FileDatabase& db,
     const Field&,
     bool
-) const 
+) const
 {
     // Special case when the data type needs to be determined at runtime.
     // Less secure than in the `strongly-typed` case.
 
     out.reset();
-    if (!ptrval.val) { 
+    if (!ptrval.val) {
         return false;
     }
 
@@ -448,7 +448,7 @@ template <> bool Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::
     const Structure& s = db.dna[block->dna_index];
 
     // try to retrieve the object from the cache
-    db.cache(out).get(s,out,ptrval); 
+    db.cache(out).get(s,out,ptrval);
     if (out) {
         return true;
     }
@@ -473,15 +473,15 @@ template <> bool Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::
 
     // allocate the object hull
     out = (s.*builders.first)();
-    
-    // cache the object immediately to prevent infinite recursion in a 
+
+    // cache the object immediately to prevent infinite recursion in a
     // circular list with a single element (i.e. a self-referencing element).
     db.cache(out).set(s,out,ptrval);
 
     // and do the actual conversion
     (s.*builders.second)(out,db);
     db.reader->SetCurrentPos(pold);
-    
+
     // store a pointer to the name string of the actual type
     // in the object itself. This allows the conversion code
     // to perform additional type checking.
@@ -495,10 +495,10 @@ template <> bool Structure :: ResolvePointer<boost::shared_ptr,ElemBase>(boost::
 }
 
 //--------------------------------------------------------------------------------
-const FileBlockHead* Structure :: LocateFileBlockForAddress(const Pointer & ptrval, const FileDatabase& db) const 
+const FileBlockHead* Structure :: LocateFileBlockForAddress(const Pointer & ptrval, const FileDatabase& db) const
 {
     // the file blocks appear in list sorted by
-    // with ascending base addresses so we can run a 
+    // with ascending base addresses so we can run a
     // binary search to locate the pointee quickly.
 
     // NOTE: Blender seems to distinguish between side-by-side
@@ -525,7 +525,7 @@ const FileBlockHead* Structure :: LocateFileBlockForAddress(const Pointer & ptrv
 }
 
 // ------------------------------------------------------------------------------------------------
-// NOTE: The MSVC debugger keeps showing up this annoying `a cast to a smaller data type has 
+// NOTE: The MSVC debugger keeps showing up this annoying `a cast to a smaller data type has
 // caused a loss of data`-warning. Avoid this warning by a masking with an appropriate bitmask.
 
 template <typename T> struct signless;
@@ -534,7 +534,7 @@ template <> struct signless<short> {typedef unsigned short type;};
 template <> struct signless<int> {typedef unsigned int type;};
 
 template <typename T>
-struct static_cast_silent { 
+struct static_cast_silent {
     template <typename V>
     T operator()(V in) {
         return static_cast<T>(in & static_cast<typename signless<T>::type>(-1));
@@ -554,7 +554,7 @@ template <> struct static_cast_silent<double> {
 };
 
 // ------------------------------------------------------------------------------------------------
-template <typename T> inline void ConvertDispatcher(T& out, const Structure& in,const FileDatabase& db) 
+template <typename T> inline void ConvertDispatcher(T& out, const Structure& in,const FileDatabase& db)
 {
     if (in.name == "int") {
         out = static_cast_silent<T>()(db.reader->GetU4());
@@ -677,7 +677,7 @@ const Structure* DNA :: Get (const std::string& ss) const
 }
 
 //--------------------------------------------------------------------------------
-const Structure& DNA :: operator [] (const size_t i) const 
+const Structure& DNA :: operator [] (const size_t i) const
 {
     if (i >= structures.size()) {
         throw Error((Formatter::format(),
@@ -690,8 +690,8 @@ const Structure& DNA :: operator [] (const size_t i) const
 
 //--------------------------------------------------------------------------------
 template <template <typename> class TOUT> template <typename T> void ObjectCache<TOUT> :: get (
-    const Structure& s, 
-    TOUT<T>& out, 
+    const Structure& s,
+    TOUT<T>& out,
     const Pointer& ptr
 ) const {
 
@@ -703,7 +703,7 @@ template <template <typename> class TOUT> template <typename T> void ObjectCache
 
     typename StructureCache::const_iterator it = caches[s.cache_idx].find(ptr);
     if (it != caches[s.cache_idx].end()) {
-        out = boost::static_pointer_cast<T>( (*it).second );
+        out = std::static_pointer_cast<T>( (*it).second );
 
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
         ++db.stats().cache_hits;
@@ -715,7 +715,7 @@ template <template <typename> class TOUT> template <typename T> void ObjectCache
 
 //--------------------------------------------------------------------------------
 template <template <typename> class TOUT> template <typename T> void ObjectCache<TOUT> :: set (
-    const Structure& s, 
+    const Structure& s,
     const TOUT<T>& out,
     const Pointer& ptr
 ) {
@@ -723,7 +723,7 @@ template <template <typename> class TOUT> template <typename T> void ObjectCache
         s.cache_idx = db.next_cache_idx++;
         caches.resize(db.next_cache_idx);
     }
-    caches[s.cache_idx][ptr] = boost::static_pointer_cast<ElemBase>( out ); 
+    caches[s.cache_idx][ptr] = std::static_pointer_cast<ElemBase>( out );
 
 #ifndef ASSIMP_BUILD_BLENDER_NO_STATS
     ++db.stats().cached_objects;

code/BlenderIntermediate.h

@@ -49,14 +49,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderDNA.h"
 #include "BlenderScene.h"
 #include "BlenderSceneGen.h"
-#include <boost/foreach.hpp>
 #include <deque>
 #include "./../include/assimp/material.h"
 
 struct aiTexture;
 
-#define for_each(x,y) BOOST_FOREACH(x,y)
-
 namespace Assimp {
 namespace Blender {
 
@@ -71,7 +68,7 @@ namespace Blender {
         }
 
         ~TempArray () {
-            for_each(T* elem, arr) {
+            for(T* elem : arr) {
                 delete elem;
             }
         }
@@ -160,7 +157,7 @@ namespace Blender {
         TempArray <std::vector, aiTexture> textures;
 
         // set of all materials referenced by at least one mesh in the scene
-        std::deque< boost::shared_ptr< Material > > materials_raw;
+        std::deque< std::shared_ptr< Material > > materials_raw;
 
         // counter to name sentinel textures inserted as substitutes for procedural textures.
         unsigned int sentinel_cnt;

code/BlenderLoader.cpp

@@ -164,7 +164,7 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
 #endif
 
     FileDatabase file;
-    boost::shared_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
+    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
     if (!stream) {
         ThrowException("Could not open file for reading");
     }
@@ -190,7 +190,7 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
 
         // http://www.gzip.org/zlib/rfc-gzip.html#header-trailer
         stream->Seek(0L,aiOrigin_SET);
-        boost::shared_ptr<StreamReaderLE> reader = boost::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
+        std::shared_ptr<StreamReaderLE> reader = std::shared_ptr<StreamReaderLE>(new StreamReaderLE(stream));
 
         // build a zlib stream
         z_stream zstream;
@@ -260,9 +260,9 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
 }
 
 // ------------------------------------------------------------------------------------------------
-void BlenderImporter::ParseBlendFile(FileDatabase& out, boost::shared_ptr<IOStream> stream)
+void BlenderImporter::ParseBlendFile(FileDatabase& out, std::shared_ptr<IOStream> stream)
 {
-    out.reader = boost::shared_ptr<StreamReaderAny>(new StreamReaderAny(stream,out.little));
+    out.reader = std::shared_ptr<StreamReaderAny>(new StreamReaderAny(stream,out.little));
 
     DNAParser dna_reader(out);
     const DNA* dna = NULL;
@@ -305,7 +305,7 @@ void BlenderImporter::ExtractScene(Scene& out, const FileDatabase& file)
     const Structure& ss = file.dna.structures[(*it).second];
 
     // we need a scene somewhere to start with.
-    for_each(const FileBlockHead& bl,file.entries) {
+    for(const FileBlockHead& bl :file.entries) {
 
         // Fix: using the DNA index is more reliable to locate scenes
         //if (bl.id == "SC") {
@@ -342,7 +342,7 @@ void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in,const FileD
     // the file. This is terrible. Here, we're first looking for
     // all objects which don't have parent objects at all -
     std::deque<const Object*> no_parents;
-    for (boost::shared_ptr<Base> cur = boost::static_pointer_cast<Base> ( in.base.first ); cur; cur = cur->next) {
+    for (std::shared_ptr<Base> cur = std::static_pointer_cast<Base> ( in.base.first ); cur; cur = cur->next) {
         if (cur->object) {
             if(!cur->object->parent) {
                 no_parents.push_back(cur->object.get());
@@ -350,7 +350,7 @@ void BlenderImporter::ConvertBlendFile(aiScene* out, const Scene& in,const FileD
             else conv.objects.insert(cur->object.get());
         }
     }
-    for (boost::shared_ptr<Base> cur = in.basact; cur; cur = cur->next) {
+    for (std::shared_ptr<Base> cur = in.basact; cur; cur = cur->next) {
         if (cur->object) {
             if(cur->object->parent) {
                 conv.objects.insert(cur->object.get());
@@ -560,12 +560,12 @@ void BlenderImporter::BuildMaterials(ConversionData& conv_data)
 
     // add a default material if necessary
     unsigned int index = static_cast<unsigned int>( -1 );
-    for_each( aiMesh* mesh, conv_data.meshes.get() ) {
+    for( aiMesh* mesh : conv_data.meshes.get() ) {
         if (mesh->mMaterialIndex == static_cast<unsigned int>( -1 )) {
 
             if (index == static_cast<unsigned int>( -1 )) {
                 // Setup a default material.
-                boost::shared_ptr<Material> p(new Material());
+                std::shared_ptr<Material> p(new Material());
                 ai_assert(::strlen(AI_DEFAULT_MATERIAL_NAME) < sizeof(p->id.name)-2);
                 strcpy( p->id.name+2, AI_DEFAULT_MATERIAL_NAME );
 
@@ -589,7 +589,7 @@ void BlenderImporter::BuildMaterials(ConversionData& conv_data)
         }
     }
 
-    for_each(boost::shared_ptr<Material> mat, conv_data.materials_raw) {
+    for(std::shared_ptr<Material> mat : conv_data.materials_raw) {
 
         // reset per material global counters
         for (size_t i = 0; i < sizeof(conv_data.next_texture)/sizeof(conv_data.next_texture[0]);++i) {
@@ -631,6 +631,12 @@ void BlenderImporter::BuildMaterials(ConversionData& conv_data)
         col = aiColor3D(mat->ambr,mat->ambg,mat->ambb);
         mout->AddProperty(&col,1,AI_MATKEY_COLOR_AMBIENT);
 
+        // is mirror enabled?
+        if( mat->mode & MA_RAYMIRROR ) {
+            const float ray_mirror = mat->ray_mirror;
+            mout->AddProperty(&ray_mirror,1,AI_MATKEY_REFLECTIVITY);
+        }
+
         col = aiColor3D(mat->mirr,mat->mirg,mat->mirb);
         mout->AddProperty(&col,1,AI_MATKEY_COLOR_REFLECTIVE);
 
@@ -716,7 +722,7 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
     temp->reserve(temp->size() + per_mat.size());
 
     std::map<size_t,size_t> mat_num_to_mesh_idx;
-    for_each(MyPair& it, per_mat) {
+    for(MyPair& it : per_mat) {
 
         mat_num_to_mesh_idx[it.first] = temp->size();
         temp->push_back(new aiMesh());
@@ -743,8 +749,8 @@ void BlenderImporter::ConvertMesh(const Scene& /*in*/, const Object* /*obj*/, co
                 ThrowException("Material index is out of range");
             }
 
-            boost::shared_ptr<Material> mat = mesh->mat[it.first];
-            const std::deque< boost::shared_ptr<Material> >::iterator has = std::find(
+            std::shared_ptr<Material> mat = mesh->mat[it.first];
+            const std::deque< std::shared_ptr<Material> >::iterator has = std::find(
                     conv_data.materials_raw.begin(),
                     conv_data.materials_raw.end(),mat
             );
@@ -1151,7 +1157,7 @@ aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, Convers
     if (children.size()) {
         node->mNumChildren = static_cast<unsigned int>(children.size());
         aiNode** nd = node->mChildren = new aiNode*[node->mNumChildren]();
-        for_each (const Object* nobj,children) {
+        for (const Object* nobj :children) {
             *nd = ConvertNode(in,nobj,conv_data,node->mTransformation * parentTransform);
             (*nd++)->mParent = node;
         }

code/BlenderLoader.h

@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BaseImporter.h"
 #include "LogAux.h"
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 struct aiNode;
 struct aiMesh;
@@ -133,7 +133,7 @@ protected:
 
     // --------------------
     void ParseBlendFile(Blender::FileDatabase& out,
-        boost::shared_ptr<IOStream> stream
+        std::shared_ptr<IOStream> stream
     );
 
     // --------------------

code/BlenderModifier.cpp

@@ -48,9 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "SceneCombiner.h"
 #include "Subdivision.h"
 #include "../include/assimp/scene.h"
-#include <boost/scoped_ptr.hpp>
-#include <boost/scoped_array.hpp>
-#include <boost/pointer_cast.hpp>
+#include <memory>
 
 #include <functional>
 
@@ -113,8 +111,8 @@ void BlenderModifierShowcase::ApplyModifiers(aiNode& out, ConversionData& conv_d
     // we're allowed to dereference the pointers without risking to crash. We might still be
     // invoking UB btw - we're assuming that the ModifierData member of the respective modifier
     // structures is at offset sizeof(vftable) with no padding.
-    const SharedModifierData* cur = boost::static_pointer_cast<const SharedModifierData> ( orig_object.modifiers.first.get() );
-    for (; cur; cur =  boost::static_pointer_cast<const SharedModifierData> ( cur->modifier.next.get() ), ++ful) {
+    const SharedModifierData* cur = static_cast<const SharedModifierData *> ( orig_object.modifiers.first.get() );
+    for (; cur; cur =  static_cast<const SharedModifierData *> ( cur->modifier.next.get() ), ++ful) {
         ai_assert(cur->dna_type);
 
         const Structure* s = conv_data.db.dna.Get( cur->dna_type );
@@ -153,7 +151,7 @@ void BlenderModifierShowcase::ApplyModifiers(aiNode& out, ConversionData& conv_d
 
             BlenderModifier* const modifier = *curmod;
             if(modifier->IsActive(dat)) {
-                modifier->DoIt(out,conv_data,*boost::static_pointer_cast<const ElemBase>(cur),in,orig_object);
+                modifier->DoIt(out,conv_data,*static_cast<const ElemBase *>(cur),in,orig_object);
                 cnt++;
 
                 curgod = NULL;
@@ -312,11 +310,11 @@ void  BlenderModifier_Subdivision :: DoIt(aiNode& out, ConversionData& conv_data
         return;
     };
 
-    boost::scoped_ptr<Subdivider> subd(Subdivider::Create(algo));
+    std::unique_ptr<Subdivider> subd(Subdivider::Create(algo));
     ai_assert(subd);
 
     aiMesh** const meshes = &conv_data.meshes[conv_data.meshes->size() - out.mNumMeshes];
-    boost::scoped_array<aiMesh*> tempmeshes(new aiMesh*[out.mNumMeshes]());
+    std::unique_ptr<aiMesh*[]> tempmeshes(new aiMesh*[out.mNumMeshes]());
 
     subd->Subdivide(meshes,out.mNumMeshes,tempmeshes.get(),std::max( mir.renderLevels, mir.levels ),true);
     std::copy(tempmeshes.get(),tempmeshes.get()+out.mNumMeshes,meshes);

code/BlenderModifier.h

@@ -46,8 +46,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BlenderIntermediate.h"
 #include "TinyFormatter.h"
+
 namespace Assimp {
-    namespace Blender {
+namespace Blender {
 
 // -------------------------------------------------------------------------------------------
 /** Dummy base class for all blender modifiers. Modifiers are reused between imports, so
@@ -56,8 +57,8 @@ namespace Assimp {
 class BlenderModifier
 {
 public:
-
     virtual ~BlenderModifier() {
+        // empty
     }
 
 public:

code/BlenderScene.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2016, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -64,7 +64,7 @@ template <> void Structure :: Convert<Object> (
     ReadFieldArray2<ErrorPolicy_Warn>(dest.parentinv,"parentinv",db);
     ReadFieldArray<ErrorPolicy_Warn>(dest.parsubstr,"parsubstr",db);
     {
-        boost::shared_ptr<Object> parent;
+        std::shared_ptr<Object> parent;
         ReadFieldPtr<ErrorPolicy_Warn>(parent,"*parent",db);
         dest.parent = parent.get();
     }
@@ -313,9 +313,11 @@ template <> void Structure :: Convert<Material> (
     ReadField<ErrorPolicy_Igno>(dest.mirg,"mirg",db);
     ReadField<ErrorPolicy_Igno>(dest.mirb,"mirb",db);
     ReadField<ErrorPolicy_Warn>(dest.emit,"emit",db);
+    ReadField<ErrorPolicy_Igno>(dest.ray_mirror,"ray_mirror",db);
     ReadField<ErrorPolicy_Warn>(dest.alpha,"alpha",db);
     ReadField<ErrorPolicy_Igno>(dest.ref,"ref",db);
     ReadField<ErrorPolicy_Igno>(dest.translucency,"translucency",db);
+    ReadField<ErrorPolicy_Igno>(dest.mode,"mode",db);
     ReadField<ErrorPolicy_Igno>(dest.roughness,"roughness",db);
     ReadField<ErrorPolicy_Igno>(dest.darkness,"darkness",db);
     ReadField<ErrorPolicy_Igno>(dest.refrac,"refrac",db);
@@ -335,7 +337,7 @@ template <> void Structure :: Convert<MTexPoly> (
 {
 
     {
-        boost::shared_ptr<Image> tpage;
+        std::shared_ptr<Image> tpage;
         ReadFieldPtr<ErrorPolicy_Igno>(tpage,"*tpage",db);
         dest.tpage = tpage.get();
     }

code/BlenderScene.h

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderDNA.h"
 
 namespace Assimp    {
-    namespace Blender {
+namespace Blender {
 
 // Minor parts of this file are extracts from blender data structures,
 // declared in the ./source/blender/makesdna directory.
@@ -73,7 +73,7 @@ namespace Assimp    {
 //
 // * Pointers to other structures or primitive types are allowed.
 //   No references or double pointers or arrays of pointers.
-//   A pointer to a T is normally written as boost::shared_ptr, while a
+//   A pointer to a T is normally written as std::shared_ptr, while a
 //   pointer to an array of elements is written as boost::
 //   shared_array. To avoid cyclic pointers, use raw pointers in
 //   one direction.
@@ -98,6 +98,8 @@ struct Object;
 struct MTex;
 struct Image;
 
+#include <memory>
+
 #define AI_BLEND_MESH_MAX_VERTS 2000000000L
 
 // -------------------------------------------------------------------------------
@@ -110,8 +112,8 @@ struct ID : ElemBase {
 // -------------------------------------------------------------------------------
 struct ListBase : ElemBase {
 
-    boost::shared_ptr<ElemBase> first;
-    boost::shared_ptr<ElemBase> last;
+    std::shared_ptr<ElemBase> first;
+    std::shared_ptr<ElemBase> last;
 };
 
 
@@ -119,14 +121,14 @@ struct ListBase : ElemBase {
 struct PackedFile : ElemBase {
      int size WARN;
      int seek WARN;
-     boost::shared_ptr< FileOffset > data WARN;
+     std::shared_ptr< FileOffset > data WARN;
 };
 
 // -------------------------------------------------------------------------------
 struct GroupObject : ElemBase {
 
-    boost::shared_ptr<GroupObject> prev,next FAIL;
-    boost::shared_ptr<Object> ob;
+    std::shared_ptr<GroupObject> prev,next FAIL;
+    std::shared_ptr<Object> ob;
 };
 
 // -------------------------------------------------------------------------------
@@ -134,7 +136,7 @@ struct Group : ElemBase {
     ID id FAIL;
     int layer;
 
-    boost::shared_ptr<GroupObject> gobject;
+    std::shared_ptr<GroupObject> gobject;
 };
 
 // -------------------------------------------------------------------------------
@@ -222,7 +224,7 @@ struct MTFace : ElemBase {
     short tile;
     short unwrap;
 
-    // boost::shared_ptr<Image> tpage;
+    // std::shared_ptr<Image> tpage;
 };
 
 // -------------------------------------------------------------------------------
@@ -239,6 +241,8 @@ struct MDeformVert : ElemBase  {
 };
 
 // -------------------------------------------------------------------------------
+#define MA_RAYMIRROR    0x40000
+
 struct Material : ElemBase {
     ID id FAIL;
 
@@ -248,19 +252,21 @@ struct Material : ElemBase {
     float ambr,ambg,ambb WARN;
     float mirr,mirg,mirb;
     float emit WARN;
+    float ray_mirror;
     float alpha WARN;
     float ref;
     float translucency;
+    int mode;
     float roughness;
     float darkness;
     float refrac;
 
-    boost::shared_ptr<Group> group;
+    std::shared_ptr<Group> group;
 
     short diff_shader WARN;
     short spec_shader WARN;
 
-    boost::shared_ptr<MTex> mtex[18];
+    std::shared_ptr<MTex> mtex[18];
 };
 
 // -------------------------------------------------------------------------------
@@ -291,7 +297,7 @@ struct Mesh : ElemBase {
     vector<MDeformVert> dvert;
     vector<MCol> mcol;
 
-    vector< boost::shared_ptr<Material> > mat FAIL;
+    vector< std::shared_ptr<Material> > mat FAIL;
 };
 
 // -------------------------------------------------------------------------------
@@ -300,7 +306,7 @@ struct Library : ElemBase {
 
     char name[240] WARN;
     char filename[240] FAIL;
-    boost::shared_ptr<Library> parent WARN;
+    std::shared_ptr<Library> parent WARN;
 };
 
 // -------------------------------------------------------------------------------
@@ -440,8 +446,8 @@ struct ModifierData : ElemBase  {
       eModifierType_ShapeKey
     };
 
-    boost::shared_ptr<ElemBase> next WARN;
-    boost::shared_ptr<ElemBase> prev WARN;
+    std::shared_ptr<ElemBase> next WARN;
+    std::shared_ptr<ElemBase> prev WARN;
 
     int type, mode;
     char name[32];
@@ -485,7 +491,7 @@ struct MirrorModifierData : ElemBase {
 
     short axis, flag;
     float tolerance;
-    boost::shared_ptr<Object> mirror_ob;
+    std::shared_ptr<Object> mirror_ob;
 };
 
 // -------------------------------------------------------------------------------
@@ -513,11 +519,11 @@ struct Object : ElemBase  {
     char parsubstr[32] WARN;
 
     Object* parent WARN;
-    boost::shared_ptr<Object> track WARN;
+    std::shared_ptr<Object> track WARN;
 
-    boost::shared_ptr<Object> proxy,proxy_from,proxy_group WARN;
-    boost::shared_ptr<Group> dup_group WARN;
-    boost::shared_ptr<ElemBase> data FAIL;
+    std::shared_ptr<Object> proxy,proxy_from,proxy_group WARN;
+    std::shared_ptr<Group> dup_group WARN;
+    std::shared_ptr<ElemBase> data FAIL;
 
     ListBase modifiers;
 };
@@ -526,17 +532,17 @@ struct Object : ElemBase  {
 // -------------------------------------------------------------------------------
 struct Base : ElemBase {
     Base* prev WARN;
-    boost::shared_ptr<Base> next WARN;
-    boost::shared_ptr<Object> object WARN;
+    std::shared_ptr<Base> next WARN;
+    std::shared_ptr<Object> object WARN;
 };
 
 // -------------------------------------------------------------------------------
 struct Scene : ElemBase {
     ID id FAIL;
 
-    boost::shared_ptr<Object> camera WARN;
-    boost::shared_ptr<World> world WARN;
-    boost::shared_ptr<Base> basact WARN;
+    std::shared_ptr<Object> camera WARN;
+    std::shared_ptr<World> world WARN;
+    std::shared_ptr<Base> basact WARN;
 
     ListBase base;
 };
@@ -560,7 +566,7 @@ struct Image : ElemBase {
     //unsigned int bindcode;
     //unsigned int *repbind;
 
-    boost::shared_ptr<PackedFile> packedfile;
+    std::shared_ptr<PackedFile> packedfile;
     //struct PreviewImage * preview;
 
     float lastupdate;
@@ -646,7 +652,7 @@ struct Tex : ElemBase {
 
     //bNodeTree *nodetree;
     //Ipo *ipo;
-    boost::shared_ptr<Image> ima WARN;
+    std::shared_ptr<Image> ima WARN;
     //PluginTex *plugin;
     //ColorBand *coba;
     //EnvMap *env;
@@ -713,8 +719,8 @@ struct MTex : ElemBase {
     MapType mapto;
 
     BlendType blendtype;
-    boost::shared_ptr<Object> object;
-    boost::shared_ptr<Tex> tex;
+    std::shared_ptr<Object> object;
+    std::shared_ptr<Tex> tex;
     char uvname[32];
 
     Projection projx,projy,projz;

code/BlenderSceneGen.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (ASSIMP)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2010, ASSIMP Development Team
+Copyright (c) 2006-2016, ASSIMP Development Team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -48,8 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderScene.h"
 
 namespace Assimp    {
-    namespace Blender {
-
+namespace Blender {
 
 template <> void Structure :: Convert<Object> (
     Object& dest,

code/BlenderTessellator.cpp

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2013, assimp team
+Copyright (c) 2006-2016, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,
@@ -140,7 +140,7 @@ void BlenderTessellatorGL::TriangulateDrawCalls( const TessDataGL& tessData )
 {
     // NOTE - Because we are supplying a callback to GLU_TESS_EDGE_FLAG_DATA we don't technically
     //        need support for GL_TRIANGLE_STRIP and GL_TRIANGLE_FAN but we'll keep it here in case
-    //        GLU tessellate changes or tristrips and fans are wanted.
+    //        GLU tessellate changes or tri-strips and fans are wanted.
     //        See: http://www.opengl.org/sdk/docs/man2/xhtml/gluTessCallback.xml
     for ( unsigned int i = 0; i < tessData.drawCalls.size( ); ++i )
     {
@@ -164,7 +164,7 @@ void BlenderTessellatorGL::TriangulateDrawCalls( const TessDataGL& tessData )
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorGL::MakeFacesFromTris( const VertexGL* vertices, int vertexCount )
 {
-    int triangleCount = vertexCount / 3;
+    const int triangleCount = vertexCount / 3;
     for ( int i = 0; i < triangleCount; ++i )
     {
         int vertexBase = i * 3;
@@ -175,7 +175,7 @@ void BlenderTessellatorGL::MakeFacesFromTris( const VertexGL* vertices, int vert
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorGL::MakeFacesFromTriStrip( const VertexGL* vertices, int vertexCount )
 {
-    int triangleCount = vertexCount - 2;
+    const int triangleCount = vertexCount - 2;
     for ( int i = 0; i < triangleCount; ++i )
     {
         int vertexBase = i;
@@ -186,7 +186,7 @@ void BlenderTessellatorGL::MakeFacesFromTriStrip( const VertexGL* vertices, int
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorGL::MakeFacesFromTriFan( const VertexGL* vertices, int vertexCount )
 {
-    int triangleCount = vertexCount - 2;
+    const int triangleCount = vertexCount - 2;
     for ( int i = 0; i < triangleCount; ++i )
     {
         int vertexBase = i;
@@ -353,7 +353,7 @@ aiMatrix4x4 BlenderTessellatorP2T::GeneratePointTransformMatrix( const Blender::
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorP2T::TransformAndFlattenVectices( const aiMatrix4x4& transform, std::vector< Blender::PointP2T >& vertices ) const
 {
-    for ( unsigned int i = 0; i < vertices.size( ); ++i )
+    for ( size_t i = 0; i < vertices.size( ); ++i )
     {
         PointP2T& point = vertices[ i ];
         point.point3D = transform * point.point3D;
@@ -365,7 +365,7 @@ void BlenderTessellatorP2T::TransformAndFlattenVectices( const aiMatrix4x4& tran
 void BlenderTessellatorP2T::ReferencePoints( std::vector< Blender::PointP2T >& points, std::vector< p2t::Point* >& pointRefs ) const
 {
     pointRefs.resize( points.size( ) );
-    for ( unsigned int i = 0; i < points.size( ); ++i )
+    for ( size_t i = 0; i < points.size( ); ++i )
     {
         pointRefs[ i ] = &points[ i ].point2D;
     }
@@ -391,7 +391,7 @@ inline PointP2T& BlenderTessellatorP2T::GetActualPointStructure( p2t::Point& poi
 // ------------------------------------------------------------------------------------------------
 void BlenderTessellatorP2T::MakeFacesFromTriangles( std::vector< p2t::Triangle* >& triangles ) const
 {
-    for ( unsigned int i = 0; i < triangles.size( ); ++i )
+    for ( size_t i = 0; i < triangles.size( ); ++i )
     {
         p2t::Triangle& Triangle = *triangles[ i ];
 
@@ -415,9 +415,9 @@ float BlenderTessellatorP2T::FindLargestMatrixElem( const aiMatrix3x3& mtx ) con
 {
     float result = 0.0f;
 
-    for ( int x = 0; x < 3; ++x )
+    for ( size_t x = 0; x < 3; ++x )
     {
-        for ( int y = 0; y < 3; ++y )
+        for ( size_t y = 0; y < 3; ++y )
         {
             result = p2tMax( std::fabs( mtx[ x ][ y ] ), result );
         }
@@ -427,14 +427,14 @@ float BlenderTessellatorP2T::FindLargestMatrixElem( const aiMatrix3x3& mtx ) con
 }
 
 // ------------------------------------------------------------------------------------------------
-// Aparently Assimp doesn't have matrix scaling
+// Apparently Assimp doesn't have matrix scaling
 aiMatrix3x3 BlenderTessellatorP2T::ScaleMatrix( const aiMatrix3x3& mtx, float scale ) const
 {
     aiMatrix3x3 result;
 
-    for ( int x = 0; x < 3; ++x )
+    for ( size_t x = 0; x < 3; ++x )
     {
-        for ( int y = 0; y < 3; ++y )
+        for ( size_t y = 0; y < 3; ++y )
         {
             result[ x ][ y ] = mtx[ x ][ y ] * scale;
         }
@@ -448,7 +448,7 @@ aiMatrix3x3 BlenderTessellatorP2T::ScaleMatrix( const aiMatrix3x3& mtx, float sc
 // Adapted from: http://missingbytes.blogspot.co.uk/2012/06/fitting-plane-to-point-cloud.html
 aiVector3D BlenderTessellatorP2T::GetEigenVectorFromLargestEigenValue( const aiMatrix3x3& mtx ) const
 {
-    float scale = FindLargestMatrixElem( mtx );
+    const float scale = FindLargestMatrixElem( mtx );
     aiMatrix3x3 mc = ScaleMatrix( mtx, 1.0f / scale );
     mc = mc * mc * mc;
 
@@ -474,7 +474,7 @@ PlaneP2T BlenderTessellatorP2T::FindLLSQPlane( const std::vector< PointP2T >& po
     PlaneP2T result;
 
     aiVector3D sum( 0.0f );
-    for ( unsigned int i = 0; i < points.size( ); ++i )
+    for ( size_t i = 0; i < points.size( ); ++i )
     {
         sum += points[ i ].point3D;
     }
@@ -486,7 +486,7 @@ PlaneP2T BlenderTessellatorP2T::FindLLSQPlane( const std::vector< PointP2T >& po
     float sumYY = 0.0f;
     float sumYZ = 0.0f;
     float sumZZ = 0.0f;
-    for ( unsigned int i = 0; i < points.size( ); ++i )
+    for ( size_t i = 0; i < points.size( ); ++i )
     {
         aiVector3D offset = points[ i ].point3D - result.centre;
         sumXX += offset.x * offset.x;
@@ -499,7 +499,7 @@ PlaneP2T BlenderTessellatorP2T::FindLLSQPlane( const std::vector< PointP2T >& po
 
     aiMatrix3x3 mtx( sumXX, sumXY, sumXZ, sumXY, sumYY, sumYZ, sumXZ, sumYZ, sumZZ );
 
-    float det = mtx.Determinant( );
+    const float det = mtx.Determinant( );
     if ( det == 0.0f )
     {
         result.normal = aiVector3D( 0.0f );

code/BlenderTessellator.h

@@ -2,7 +2,7 @@
 Open Asset Import Library (assimp)
 ----------------------------------------------------------------------
 
-Copyright (c) 2006-2013, assimp team
+Copyright (c) 2006-2016, assimp team
 All rights reserved.
 
 Redistribution and use of this software in source and binary forms,

code/BlobIOSystem.h

@@ -49,7 +49,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "./../include/assimp/cexport.h"
 #include "./../include/assimp/IOSystem.hpp"
 #include "./../include/assimp/DefaultLogger.hpp"
-#include <boost/foreach.hpp>
 #include <stdint.h>
 #include <set>
 #include <vector>
@@ -224,7 +223,7 @@ public:
 
     virtual ~BlobIOSystem()
     {
-        BOOST_FOREACH(BlobEntry& blobby, blobs) {
+        for(BlobEntry& blobby : blobs) {
             delete blobby.second;
         }
     }
@@ -243,7 +242,7 @@ public:
     {
         // one must be the master
         aiExportDataBlob* master = NULL, *cur;
-        BOOST_FOREACH(const BlobEntry& blobby, blobs) {
+        for(const BlobEntry& blobby : blobs) {
             if (blobby.first == AI_BLOBIO_MAGIC) {
                 master = blobby.second;
                 break;
@@ -257,7 +256,7 @@ public:
         master->name.Set("");
 
         cur = master;
-        BOOST_FOREACH(const BlobEntry& blobby, blobs) {
+        for(const BlobEntry& blobby : blobs) {
             if (blobby.second == master) {
                 continue;
             }

code/BoostWorkaround/boost/LICENSE_1_0.txt

@@ -1,23 +0,0 @@
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

code/BoostWorkaround/boost/foreach.hpp

@@ -1,99 +0,0 @@
-
-#ifndef BOOST_FOREACH
-
-///////////////////////////////////////////////////////////////////////////////
-// A stripped down version of FOREACH for
-// illustration purposes. NOT FOR GENERAL USE.
-// For a complete implementation, see BOOST_FOREACH at
-// http://boost-sandbox.sourceforge.net/vault/index.php?directory=eric_niebler
-//
-// Copyright 2004 Eric Niebler.
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-// Adapted to Assimp November 29th, 2008 (Alexander Gessler).
-// Added code to handle both const and non-const iterators, simplified some
-// parts.
-///////////////////////////////////////////////////////////////////////////////
-
-namespace boost {
-namespace foreach_detail {
-
-///////////////////////////////////////////////////////////////////////////////
-// auto_any
-
-struct auto_any_base
-{
-    operator bool() const { return false; }
-};
-
-template<typename T>
-struct auto_any : auto_any_base
-{
-    auto_any(T const& t) : item(t) {}
-    mutable T item;
-};
-
-template<typename T>
-T& auto_any_cast(auto_any_base const& any)
-{
-    return static_cast<auto_any<T> const&>(any).item;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-// FOREACH helper function
-
-template<typename T>
-auto_any<typename T::const_iterator> begin(T const& t)
-{
-    return t.begin();
-}
-
-template<typename T>
-auto_any<typename T::const_iterator> end(T const& t)
-{
-    return t.end();
-}
-
-// iterator
-template<typename T>
-bool done(auto_any_base const& cur, auto_any_base const& end, T&)
-{
-    typedef typename T::iterator iter_type;
-    return auto_any_cast<iter_type>(cur) == auto_any_cast<iter_type>(end);
-}
-
-template<typename T>
-void next(auto_any_base const& cur, T&)
-{
-    ++auto_any_cast<typename T::iterator>(cur);
-}
-
-template<typename T>
-typename T::reference deref(auto_any_base const& cur, T&)
-{
-    return *auto_any_cast<typename T::iterator>(cur);
-}
-
-template<typename T>
-typename T::const_reference deref(auto_any_base const& cur, const T&)
-{
-    return *auto_any_cast<typename T::iterator>(cur);
-}
-
-} // end foreach_detail
-
-///////////////////////////////////////////////////////////////////////////////
-// FOREACH
-
-#define BOOST_FOREACH(item, container)                      \
-	if(boost::foreach_detail::auto_any_base const& foreach_magic_b = boost::foreach_detail::begin(container)) {} else       \
-    if(boost::foreach_detail::auto_any_base const& foreach_magic_e = boost::foreach_detail::end(container))   {} else       \
-    for(;!boost::foreach_detail::done(foreach_magic_b,foreach_magic_e,container);  boost::foreach_detail::next(foreach_magic_b,container))   \
-        if (bool ugly_and_unique_break = false) {} else							\
-        for(item = boost::foreach_detail::deref(foreach_magic_b,container); !ugly_and_unique_break; ugly_and_unique_break = true)
-
-} // end boost
-
-#endif

code/BoostWorkaround/boost/format.hpp

@@ -1,82 +0,0 @@
-
-
-
-/* DEPRECATED! - use code/TinyFormatter.h instead.
- *
- *
- * */
-
-#ifndef AI_BOOST_FORMAT_DUMMY_INCLUDED
-#define AI_BOOST_FORMAT_DUMMY_INCLUDED
-
-#if (!defined BOOST_FORMAT_HPP) || (defined ASSIMP_FORCE_NOBOOST)
-
-#include <string>
-#include <vector>
-#include <sstream> 
-
-namespace boost
-{
-
-
-	class format
-	{
-	public:
-		format (const std::string& _d)
-			: d(_d)
-		{
-		}
-
-		template <typename T>
-		format& operator % (T in) 
-		{
-			// XXX add replacement for boost::lexical_cast?
-			
-			std::ostringstream ss;
-			ss << in; // note: ss cannot be an rvalue, or  the global operator << (const char*) is not called for T == const char*.
-			chunks.push_back( ss.str());
-			return *this;
-		}
-
-
-		operator std::string () const {
-			std::string res; // pray for NRVO to kick in
-
-			size_t start = 0, last = 0;
-
-			std::vector<std::string>::const_iterator chunkin = chunks.begin();
-
-			for ( start = d.find('%');start != std::string::npos;  start = d.find('%',last)) {
-				res += d.substr(last,start-last);
-				last = start+2;
-				if (d[start+1] == '%') {
-					res += "%";
-					continue;
-				}
-
-				if (chunkin == chunks.end()) {
-					break;
-				}
-
-				res += *chunkin++;
-			}
-			res += d.substr(last);
-			return res;
-		}
-
-	private:
-		std::string d;
-		std::vector<std::string> chunks;
-	};
-
-	inline std::string str(const std::string& s) {
-		return s;
-	} 
-}
-
-
-#else
-#	error "format.h was already included"
-#endif //
-#endif // !! AI_BOOST_FORMAT_DUMMY_INCLUDED
-

code/BoostWorkaround/boost/lexical_cast.hpp

@@ -1,26 +0,0 @@
-/// A quick replacement for boost::lexical_cast for all the Boost haters out there
-
-#ifndef __AI_BOOST_WORKAROUND_LEXICAL_CAST
-#define __AI_BOOST_WORKAROUND_LEXICAL_CAST
-
-#include <sstream>
-
-namespace boost
-{
-
-	/// A quick replacement for boost::lexical_cast - should work for all types a stringstream can handle
-	template <typename TargetType, typename SourceType>
-	TargetType lexical_cast( const SourceType& source)
-	{
-		std::stringstream stream;
-		TargetType result;
-
-		stream << source;
-		stream >> result;
-		return result;
-	}
-
-} // namespace boost
-
-#endif // __AI_BOOST_WORKAROUND_LEXICAL_CAST
-

code/BoostWorkaround/boost/make_shared.hpp

@@ -1,57 +0,0 @@
-
-// please note that this replacement implementation does not
-// provide the performance benefit of the original, which
-// makes only one allocation as opposed to two allocations
-// (smart pointer counter and payload) which are usually
-// required if object and smart pointer are constructed
-// independently.
-
-#ifndef INCLUDED_AI_BOOST_MAKE_SHARED
-#define INCLUDED_AI_BOOST_MAKE_SHARED
-
-
-namespace boost {
-
-	template <typename T>
-	shared_ptr<T> make_shared() {
-		return shared_ptr<T>(new T());
-	}
-
-	template <typename T, typename T0>
-	shared_ptr<T> make_shared(const T0& t0) {
-		return shared_ptr<T>(new T(t0));
-	}
-
-	template <typename T, typename T0,typename T1>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1) {
-		return shared_ptr<T>(new T(t0,t1));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2) {
-		return shared_ptr<T>(new T(t0,t1,t2));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3, typename T4>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3,t4));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3, typename T4, typename T5>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3,t4,t5));
-	}
-
-	template <typename T, typename T0,typename T1,typename T2,typename T3, typename T4, typename T5, typename T6>
-	shared_ptr<T> make_shared(const T0& t0, const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
-		return shared_ptr<T>(new T(t0,t1,t2,t3,t4,t5,t6));
-	}
-}
-
-
-#endif 

code/BoostWorkaround/boost/math/common_factor_rt.hpp

@@ -1,37 +0,0 @@
-
-
-#ifndef BOOST_MATH_COMMON_FACTOR_RT_HPP
-#define BOOST_MATH_COMMON_FACTOR_RT_HPP
-
-
-namespace boost	{
-namespace math	{
-
-// TODO: use binary GCD for unsigned integers ....
-template < typename IntegerType >
-IntegerType  gcd( IntegerType a, IntegerType b )
-{
-	const IntegerType zero = (IntegerType)0;
-	while ( true )
-	{
-		if ( a == zero )
-			return b;
-		b %= a;
-
-		if ( b == zero )
-			return a;
-		a %= b;
-	}
-}
-
-template < typename IntegerType >
-IntegerType  lcm( IntegerType a, IntegerType b )
-{
-	const IntegerType t = gcd (a,b);
-	if (!t)return t;
-	return a / t * b;
-}
-
-}}
-
-#endif

code/BoostWorkaround/boost/noncopyable.hpp

@@ -1,36 +0,0 @@
-//  Boost noncopyable.hpp header file  --------------------------------------//
-
-//  (C) Copyright Beman Dawes 1999-2003. Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/utility for documentation.
-
-#ifndef BOOST_NONCOPYABLE_HPP_INCLUDED
-#define BOOST_NONCOPYABLE_HPP_INCLUDED
-
-namespace boost {
-
-//  Private copy constructor and copy assignment ensure classes derived from
-//  class noncopyable cannot be copied.
-
-//  Contributed by Dave Abrahams
-
-namespace noncopyable_  // protection from unintended ADL
-{
-  class noncopyable
-  {
-   protected:
-      noncopyable() {}
-      ~noncopyable() {}
-   private:  // emphasize the following members are private
-      noncopyable( const noncopyable& );
-      const noncopyable& operator=( const noncopyable& );
-  };
-}
-
-typedef noncopyable_::noncopyable noncopyable;
-
-} // namespace boost
-
-#endif  // BOOST_NONCOPYABLE_HPP_INCLUDED

code/BoostWorkaround/boost/pointer_cast.hpp

@@ -1,45 +0,0 @@
-//////////////////////////////////////////////////////////////////////////////
-//
-// (C) Copyright Ion Gaztanaga 2005. 
-// Distributed under the Boost Software License, Version 1.0. 
-// (See accompanying file LICENSE_1_0.txt or copy at 
-//  http://www.boost.org/LICENSE_1_0.txt)
-//
-//////////////////////////////////////////////////////////////////////////////
-
-#ifndef BOOST_POINTER_CAST_HPP
-#define BOOST_POINTER_CAST_HPP
-
-namespace boost { 
-
-//static_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* static_pointer_cast(U *ptr)
-{  
-   return static_cast<T*>(ptr);
-}
-
-//dynamic_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* dynamic_pointer_cast(U *ptr)
-{  
-   return dynamic_cast<T*>(ptr);
-}
-
-//const_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* const_pointer_cast(U *ptr)
-{  
-   return const_cast<T*>(ptr);
-}
-
-//reinterpret_pointer_cast overload for raw pointers
-template<class T, class U>
-inline T* reinterpret_pointer_cast(U *ptr)
-{  
-   return reinterpret_cast<T*>(ptr);
-}
-
-} // namespace boost
-
-#endif   //BOOST_POINTER_CAST_HPP

code/BoostWorkaround/boost/scoped_array.hpp

@@ -1,79 +0,0 @@
-
-#ifndef __AI_BOOST_SCOPED_ARRAY_INCLUDED
-#define __AI_BOOST_SCOPED_ARRAY_INCLUDED
-
-#ifndef BOOST_SCOPED_ARRAY_HPP_INCLUDED
-
-namespace boost {
-
-// small replacement for boost::scoped_array
-template <class T>
-class scoped_array
-{
-public:
-
-	// provide a default construtctor
-	scoped_array()
-		: ptr(0)
-	{
-	}
-
-	// construction from an existing heap object of type T
-	scoped_array(T* _ptr)
-		: ptr(_ptr)
-	{
-	}
-
-	// automatic destruction of the wrapped object at the
-	// end of our lifetime
-	~scoped_array()
-	{
-		delete[] ptr;
-	}
-
-	inline T* get()
-	{
-		return ptr;
-	}
-
-	inline T* operator-> ()
-	{
-		return ptr;
-	}
-
-	inline void reset (T* t = 0)
-	{
-		delete[] ptr;
-		ptr = t;
-	}
-
-	T & operator[](std::ptrdiff_t i) const
-	{
-		return ptr[i];
-	}
-
-	void swap(scoped_array & b)
-	{
-		std::swap(ptr, b.ptr);
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-};
-
-template<class T>
-inline void swap(scoped_array<T> & a, scoped_array<T> & b)
-{
-	a.swap(b);
-}
-
-} // end of namespace boost
-
-#else
-#	error "scoped_array.h was already included"
-#endif
-#endif // __AI_BOOST_SCOPED_ARRAY_INCLUDED
-

code/BoostWorkaround/boost/scoped_ptr.hpp

@@ -1,79 +0,0 @@
-
-#ifndef __AI_BOOST_SCOPED_PTR_INCLUDED
-#define __AI_BOOST_SCOPED_PTR_INCLUDED
-
-#ifndef BOOST_SCOPED_PTR_HPP_INCLUDED
-
-namespace boost {
-
-// small replacement for boost::scoped_ptr
-template <class T>
-class scoped_ptr
-{
-public:
-
-	// provide a default construtctor
-	scoped_ptr()
-		: ptr(0)
-	{
-	}
-
-	// construction from an existing heap object of type T
-	scoped_ptr(T* _ptr)
-		: ptr(_ptr)
-	{
-	}
-
-	// automatic destruction of the wrapped object at the
-	// end of our lifetime
-	~scoped_ptr()
-	{
-		delete ptr;
-	}
-
-	inline T* get() const
-	{
-		return ptr;
-	}
-
-	inline operator T*()
-	{
-		return ptr;
-	}
-
-	inline T* operator-> ()
-	{
-		return ptr;
-	}
-
-	inline void reset (T* t = 0)
-	{
-		delete ptr;
-		ptr = t;
-	}
-
-	void swap(scoped_ptr & b)
-	{
-		std::swap(ptr, b.ptr);
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-};
-
-template<class T>
-inline void swap(scoped_ptr<T> & a, scoped_ptr<T> & b)
-{
-	a.swap(b);
-}
-
-} // end of namespace boost
-
-#else
-#	error "scoped_ptr.h was already included"
-#endif
-#endif // __AI_BOOST_SCOPED_PTR_INCLUDED
-

code/BoostWorkaround/boost/shared_array.hpp

@@ -1,228 +0,0 @@
-
-#ifndef INCLUDED_AI_BOOST_SHARED_ARRAY
-#define INCLUDED_AI_BOOST_SHARED_ARRAY
-
-#ifndef BOOST_SHARED_ARRAY_HPP_INCLUDED
-
-// ------------------------------
-// Internal stub
-namespace boost {
-	namespace array_detail {
-		class controller {
-		public:
-
-			controller()
-				: cnt(1)
-			{}
-		
-		public:
-
-			template <typename T>
-			controller* decref(T* pt) {
-				if (--cnt <= 0) {
-					delete this;
-					delete[] pt;
-				}
-				return NULL;
-			}
-		
-			controller* incref() {
-				++cnt;
-				return this;
-			}
-
-			long get() const {
-				return cnt;
-			}
-
-		private:
-			long cnt;
-		};
-
-		struct empty {};
-		
-		template <typename DEST, typename SRC>
-		struct is_convertible_stub {
-			
-			struct yes {char s[1];};
-			struct no  {char s[2];};
-
-			static yes foo(DEST*);
-			static no  foo(...);
-
-			enum {result = (sizeof(foo((SRC*)0)) == sizeof(yes) ? 1 : 0)};	
-		};
-
-		template <bool> struct enable_if {};
-		template <> struct enable_if<true> {
-			typedef empty result;
-		};
-
-		template <typename DEST, typename SRC>
-		struct is_convertible : public enable_if<is_convertible_stub<DEST,SRC>::result > {
-		};
-	}
-
-// ------------------------------
-// Small replacement for boost::shared_array, not threadsafe because no
-// atomic reference counter is in use.
-// ------------------------------
-template <class T>
-class shared_array
-{
-	template <typename TT> friend class shared_array;
-
-	template<class TT> friend bool operator== (const shared_array<TT>& a, const shared_array<TT>& b);
-	template<class TT> friend bool operator!= (const shared_array<TT>& a, const shared_array<TT>& b);
-	template<class TT> friend bool operator<  (const shared_array<TT>& a, const shared_array<TT>& b);
-
-public:
-
-	typedef T element_type;
-
-public:
-
-	// provide a default constructor
-	shared_array()
-		: ptr()
-		, ctr(NULL)
-	{
-	}
-
-	// construction from an existing object of type T
-	explicit shared_array(T* ptr)
-		: ptr(ptr)
-		, ctr(ptr ? new array_detail::controller() : NULL)
-	{
-	}
-
-	shared_array(const shared_array& r)
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	template <typename Y>
-	shared_array(const shared_array<Y>& r,typename detail::is_convertible<T,Y>::result = detail::empty())
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	// automatic destruction of the wrapped object when all
-	// references are freed.
-	~shared_array()	{
-		if (ctr) {
-			ctr = ctr->decref(ptr);
-		}
-	}
-
-	shared_array& operator=(const shared_array& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	template <typename Y>
-	shared_array& operator=(const shared_array<Y>& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	// pointer access
-	inline operator T*()	{
-		return ptr;
-	}
-
-	inline T* operator-> () const	{
-		return ptr;
-	}
-
-	// standard semantics
-	inline T* get() {
-		return ptr;
-	}
-
-	T& operator[] (std::ptrdiff_t index) const {
-		return ptr[index];
-	}
-
-	inline const T* get() const	{
-		return ptr;
-	}
-
-	inline operator bool () const {
-		return ptr != NULL;
-	}
-
-	inline bool unique() const {
-		return use_count() == 1;
-	}
-
-	inline long use_count() const {
-		return ctr->get();
-	}
-
-	inline void reset (T* t = 0)	{
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = t;
-		ctr = ptr?new array_detail::controller():NULL;
-	}
-
-	void swap(shared_array & b)	{
-		std::swap(ptr, b.ptr);
-		std::swap(ctr, b.ctr);
-	}
-
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-	// control block
-	array_detail::controller* ctr;
-};
-
-template<class T>
-inline void swap(shared_array<T> & a, shared_array<T> & b)
-{
-	a.swap(b);
-}
-
-template<class T>
-bool operator== (const shared_array<T>& a, const shared_array<T>& b) {
-	return a.ptr == b.ptr;
-}
-template<class T>
-bool operator!= (const shared_array<T>& a, const shared_array<T>& b) {
-	return a.ptr != b.ptr;
-}
-	
-template<class T>
-bool operator< (const shared_array<T>& a, const shared_array<T>& b) {
-	return a.ptr < b.ptr;
-}
-
-
-} // end of namespace boost
-
-#else
-#	error "shared_array.h was already included"
-#endif
-#endif // INCLUDED_AI_BOOST_SHARED_ARRAY

code/BoostWorkaround/boost/shared_ptr.hpp

@@ -1,260 +0,0 @@
-
-#ifndef INCLUDED_AI_BOOST_SHARED_PTR
-#define INCLUDED_AI_BOOST_SHARED_PTR
-
-#ifndef BOOST_SHARED_PTR_HPP_INCLUDED
-
-// ------------------------------
-// Internal stub
-
-#include <stddef.h> //NULL
-#include <algorithm> //std::swap
-namespace boost {
-	namespace detail {
-		class controller {
-		public:
-
-			controller()
-				: cnt(1)
-			{}
-		
-		public:
-
-			template <typename T>
-			controller* decref(T* pt) {
-				if (--cnt <= 0) {
-					delete this;
-					delete pt;
-				}
-				return NULL;
-			}
-		
-			controller* incref() {
-				++cnt;
-				return this;
-			}
-
-			long get() const {
-				return cnt;
-			}
-
-		private:
-			long cnt;
-		};
-
-		struct empty {};
-		
-		template <typename DEST, typename SRC>
-		struct is_convertible_stub {
-			
-			struct yes {char s[1];};
-			struct no  {char s[2];};
-
-			static yes foo(DEST*);
-			static no  foo(...);
-
-			enum {result = (sizeof(foo((SRC*)0)) == sizeof(yes) ? 1 : 0)};	
-		};
-
-		template <bool> struct enable_if {};
-		template <> struct enable_if<true> {
-			typedef empty result;
-		};
-
-		template <typename DEST, typename SRC>
-		struct is_convertible : public enable_if<is_convertible_stub<DEST,SRC>::result > {
-		};
-	}
-
-// ------------------------------
-// Small replacement for boost::shared_ptr, not threadsafe because no
-// atomic reference counter is in use.
-// ------------------------------
-template <class T>
-class shared_ptr
-{
-	template <typename TT> friend class shared_ptr;
-
-	template<class TT, class U> friend shared_ptr<TT> static_pointer_cast   (shared_ptr<U> ptr);
-	template<class TT, class U> friend shared_ptr<TT> dynamic_pointer_cast  (shared_ptr<U> ptr);
-	template<class TT, class U> friend shared_ptr<TT> const_pointer_cast    (shared_ptr<U> ptr);
-
-	template<class TT> friend bool operator== (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-	template<class TT> friend bool operator!= (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-	template<class TT> friend bool operator<  (const shared_ptr<TT>& a, const shared_ptr<TT>& b);
-
-public:
-
-	typedef T element_type;
-
-public:
-
-	// provide a default constructor
-	shared_ptr()
-		: ptr()
-		, ctr(NULL)
-	{
-	}
-
-	// construction from an existing object of type T
-	explicit shared_ptr(T* ptr)
-		: ptr(ptr)
-		, ctr(ptr ? new detail::controller() : NULL)
-	{
-	}
-
-	shared_ptr(const shared_ptr& r)
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	template <typename Y>
-	shared_ptr(const shared_ptr<Y>& r,typename detail::is_convertible<T,Y>::result = detail::empty())
-		: ptr(r.ptr)
-		, ctr(r.ctr ? r.ctr->incref() : NULL)
-	{
-	}
-
-	// automatic destruction of the wrapped object when all
-	// references are freed.
-	~shared_ptr()	{
-		if (ctr) {
-			ctr = ctr->decref(ptr);
-		}
-	}
-
-	shared_ptr& operator=(const shared_ptr& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	template <typename Y>
-	shared_ptr& operator=(const shared_ptr<Y>& r) {
-		if (this == &r) {
-			return *this;
-		}
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = r.ptr;
-		ctr = ptr?r.ctr->incref():NULL;
-		return *this;
-	}
-
-	// pointer access
-	inline operator T*() const {
-		return ptr;
-	}
-
-	inline T* operator-> () const	{
-		return ptr;
-	}
-
-	// standard semantics
-	inline T* get() {
-		return ptr;
-	}
-
-	inline const T* get() const	{
-		return ptr;
-	}
-
-	inline operator bool () const {
-		return ptr != NULL;
-	}
-
-	inline bool unique() const {
-		return use_count() == 1;
-	}
-
-	inline long use_count() const {
-		return ctr->get();
-	}
-
-	inline void reset (T* t = 0)	{
-		if (ctr) {
-			ctr->decref(ptr);
-		}
-		ptr = t;
-		ctr = ptr?new detail::controller():NULL;
-	}
-
-	void swap(shared_ptr & b)	{
-		std::swap(ptr, b.ptr);
-		std::swap(ctr, b.ctr);
-	}
-
-private:
-
-
-	// for use by the various xxx_pointer_cast helper templates
-	explicit shared_ptr(T* ptr, detail::controller* ctr)
-		: ptr(ptr)
-		, ctr(ctr->incref())
-	{
-	}
-
-private:
-
-	// encapsulated object pointer
-	T* ptr;
-
-	// control block
-	detail::controller* ctr;
-};
-
-template<class T>
-inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
-{
-	a.swap(b);
-}
-
-template<class T>
-bool operator== (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr == b.ptr;
-}
-template<class T>
-bool operator!= (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr != b.ptr;
-}
-	
-template<class T>
-bool operator< (const shared_ptr<T>& a, const shared_ptr<T>& b) {
-	return a.ptr < b.ptr;
-}
-
-
-template<class T, class U>
-inline shared_ptr<T> static_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(static_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-template<class T, class U>
-inline shared_ptr<T> dynamic_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(dynamic_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-template<class T, class U>
-inline shared_ptr<T> const_pointer_cast( shared_ptr<U> ptr)
-{  
-   return shared_ptr<T>(const_cast<T*>(ptr.ptr),ptr.ctr);
-}
-
-
-
-} // end of namespace boost
-
-#else
-#	error "shared_ptr.h was already included"
-#endif
-#endif // INCLUDED_AI_BOOST_SHARED_PTR

code/BoostWorkaround/boost/static_assert.hpp

@@ -1,20 +0,0 @@
-
-#ifndef AI_BOOST_STATIC_ASSERT_INCLUDED
-#define AI_BOOST_STATIC_ASSERT_INCLUDED
-
-#ifndef BOOST_STATIC_ASSERT
-
-namespace boost {
-	namespace detail {
-
-		template <bool b>  class static_assertion_failure;
-		template <>        class static_assertion_failure<true> {};
-	}
-}
-
-
-#define BOOST_STATIC_ASSERT(eval) \
-{boost::detail::static_assertion_failure<(eval)> assert_dummy;(void)assert_dummy;}
-
-#endif
-#endif // !! AI_BOOST_STATIC_ASSERT_INCLUDED

code/BoostWorkaround/boost/timer.hpp

@@ -1,73 +0,0 @@
-//  boost timer.hpp header file  ---------------------------------------------//
-
-//  Copyright Beman Dawes 1994-99.  Distributed under the Boost
-//  Software License, Version 1.0. (See accompanying file
-//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
-
-//  See http://www.boost.org/libs/timer for documentation.
-
-//  Revision History
-//  01 Apr 01  Modified to use new <boost/limits.hpp> header. (JMaddock)
-//  12 Jan 01  Change to inline implementation to allow use without library
-//             builds. See docs for more rationale. (Beman Dawes) 
-//  25 Sep 99  elapsed_max() and elapsed_min() added (John Maddock)
-//  16 Jul 99  Second beta
-//   6 Jul 99  Initial boost version
-
-#ifndef BOOST_TIMER_HPP
-#define BOOST_TIMER_HPP
-
-//#include <boost/config.hpp>
-#include <ctime>
-#include <limits>
-//#include <boost/limits.hpp>
-
-# ifdef BOOST_NO_STDC_NAMESPACE
-    namespace std { using ::clock_t; using ::clock; }
-# endif
-
-
-namespace boost {
-
-//  timer  -------------------------------------------------------------------//
-
-//  A timer object measures elapsed time.
-
-//  It is recommended that implementations measure wall clock rather than CPU
-//  time since the intended use is performance measurement on systems where
-//  total elapsed time is more important than just process or CPU time.
-
-//  Warnings: The maximum measurable elapsed time may well be only 596.5+ hours
-//  due to implementation limitations.  The accuracy of timings depends on the
-//  accuracy of timing information provided by the underlying platform, and
-//  this varies a great deal from platform to platform.
-
-class timer
-{
- public:
-         timer() { _start_time = std::clock(); } // postcondition: elapsed()==0
-//         timer( const timer& src );      // post: elapsed()==src.elapsed()
-//        ~timer(){}
-//  timer& operator=( const timer& src );  // post: elapsed()==src.elapsed()
-  void   restart() { _start_time = std::clock(); } // post: elapsed()==0
-  double elapsed() const                  // return elapsed time in seconds
-    { return  double(std::clock() - _start_time) / CLOCKS_PER_SEC; }
-
-  double elapsed_max() const   // return estimated maximum value for elapsed()
-  // Portability warning: elapsed_max() may return too high a value on systems
-  // where std::clock_t overflows or resets at surprising values.
-  {
-    return (double((std::numeric_limits<std::clock_t>::max)())
-       - double(_start_time)) / double(CLOCKS_PER_SEC); 
-  }
-
-  double elapsed_min() const            // return minimum value for elapsed()
-   { return double(1)/double(CLOCKS_PER_SEC); }
-
- private:
-  std::clock_t _start_time;
-}; // timer
-
-} // namespace boost
-
-#endif  // BOOST_TIMER_HPP

code/BoostWorkaround/boost/tuple/tuple.hpp

@@ -1,283 +0,0 @@
-// A very small replacement for boost::tuple
-// (c) Alexander Gessler, 2008 [[email protected]]
-
-#ifndef BOOST_TUPLE_INCLUDED
-#define BOOST_TUPLE_INCLUDED
-
-namespace boost	{
-	namespace detail	{
-
-		// Represents an empty tuple slot (up to 5 supported)
-		struct nulltype {};
-
-		// For readable error messages
-		struct tuple_component_idx_out_of_bounds;
-
-		// To share some code for the const/nonconst versions of the getters
-		template <bool b, typename T>
-		struct ConstIf {
-			typedef T t;
-		};
-
-		template <typename T>
-		struct ConstIf<true,T> {
-			typedef const T t;
-		};
-
-		// Predeclare some stuff
-		template <typename, unsigned, typename, bool, unsigned> struct value_getter;
-
-		// Helper to obtain the type of a tuple element
-		template <typename T, unsigned NIDX, typename TNEXT, unsigned N /*= 0*/>
-		struct type_getter	{
-			typedef type_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,N> next_elem_getter;
-			typedef typename next_elem_getter::type type;
-		};
-
-		template <typename T, unsigned NIDX, typename TNEXT >
-		struct type_getter <T,NIDX,TNEXT,NIDX>	{
-			typedef T type;
-		};
-
-		// Base class for all explicit specializations of list_elem
-		template <typename T, unsigned NIDX, typename TNEXT >
-		struct list_elem_base {
-
-			// Store template parameters
-			typedef TNEXT next_type;
-			typedef T type;
-
-			static const unsigned nidx = NIDX;
-		};
-
-		// Represents an element in the tuple component list
-		template <typename T, unsigned NIDX, typename TNEXT >
-		struct list_elem : list_elem_base<T,NIDX,TNEXT>{
-
-			// Real members
-			T me;
-			TNEXT next;
-
-			// Get the value of a specific tuple element
-			template <unsigned N>
-			typename type_getter<T,NIDX,TNEXT,N>::type& get () {
-				value_getter <T,NIDX,TNEXT,false,N> s;
-				return s(*this);
-			}
-
-			// Get the value of a specific tuple element
-			template <unsigned N>
-			const typename type_getter<T,NIDX,TNEXT,N>::type& get () const {
-				value_getter <T,NIDX,TNEXT,true,N> s;
-				return s(*this);
-			}
-
-			// Explicit cast
-			template <typename T2, typename TNEXT2 >
-			operator list_elem<T2,NIDX,TNEXT2> () const	{
-				list_elem<T2,NIDX,TNEXT2> ret;
-				ret.me   = (T2)me;
-				ret.next = next;
-				return ret;
-			}
-
-			// Recursively compare two elements (last element returns always true)
-			bool operator == (const list_elem& s) const	{
-				return (me == s.me && next == s.next);
-			}
-		};
-
-		// Represents a non-used tuple element - the very last element processed
-		template <typename TNEXT, unsigned NIDX  >
-		struct list_elem<nulltype,NIDX,TNEXT> : list_elem_base<nulltype,NIDX,TNEXT> {
-			template <unsigned N, bool IS_CONST = true> struct value_getter		{
-				/* just dummy members to produce readable error messages */
-				tuple_component_idx_out_of_bounds operator () (typename ConstIf<IS_CONST,list_elem>::t& me);
-			};
-			template <unsigned N> struct type_getter  {
-				/* just dummy members to produce readable error messages */
-				typedef tuple_component_idx_out_of_bounds type;
-			};
-
-			// dummy
-			list_elem& operator = (const list_elem& /*other*/)	{
-				return *this;
-			}
-
-			// dummy
-			bool operator == (const list_elem& other)	{
-				return true;
-			}
-		};
-
-		// Represents the absolute end of the list
-		typedef list_elem<nulltype,0,int> list_end;
-
-		// Helper obtain to query the value of a tuple element
-		// NOTE: This can't be a nested class as the compiler won't accept a full or
-		// partial specialization of a nested class of a non-specialized template
-		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST, unsigned N>
-		struct value_getter	 {
-
-			// calling list_elem
-			typedef list_elem<T,NIDX,TNEXT> outer_elem;
-
-			// typedef for the getter for next element
-			typedef value_getter<typename TNEXT::type,NIDX+1,typename TNEXT::next_type,
-				IS_CONST, N> next_value_getter;
-
-			typename ConstIf<IS_CONST,typename type_getter<T,NIDX,TNEXT,N>::type>::t&
-				operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
-
-				next_value_getter s;
-				return s(me.next);
-			}
-		};
-
-		template <typename T, unsigned NIDX, typename TNEXT, bool IS_CONST>
-		struct value_getter <T,NIDX,TNEXT,IS_CONST,NIDX>	{
-			typedef list_elem<T,NIDX,TNEXT> outer_elem;
-
-			typename ConstIf<IS_CONST,T>::t& operator () (typename ConstIf<IS_CONST,outer_elem >::t& me) {
-				return me.me;
-			}
-		};
-	}
-
-	// A very minimal implementation for up to 5 elements
-	template <typename T0  = detail::nulltype,
-		      typename T1  = detail::nulltype,
-			  typename T2  = detail::nulltype,
-			  typename T3  = detail::nulltype,
-			  typename T4  = detail::nulltype>
-	class tuple	{
-
-		template <typename T0b,
-		      typename T1b,
-			  typename T2b,
-			  typename T3b,
-			  typename T4b >
-		friend class tuple;
-
-	private:
-
-		typedef detail::list_elem<T0,0,
-					detail::list_elem<T1,1,
-						detail::list_elem<T2,2,
-							detail::list_elem<T3,3,
-								detail::list_elem<T4,4,
-									detail::list_end > > > > > very_long;
-
-		very_long m;
-
-	public:
-
-		// Get a specific tuple element
-		template <unsigned N>
-		typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get ()	{
-			return m.template get<N>();
-		}
-
-		// ... and the const version
-		template <unsigned N>
-		const typename detail::type_getter<T0,0,typename very_long::next_type, N>::type& get () const	{
-			return m.template get<N>();
-		}
-
-
-		// comparison operators
-		bool operator== (const tuple& other) const	{
-			return m == other.m;
-		}
-
-		// ... and the other way round
-		bool operator!= (const tuple& other) const	{
-			return !(m == other.m);
-		}
-
-		// cast to another tuple - all single elements must be convertible
-		template <typename T0b, typename T1b,typename T2b,typename T3b, typename T4b>
-		operator tuple <T0b,T1b,T2b,T3b,T4b> () const {
-			tuple <T0b,T1b,T2b,T3b,T4b> s;
-			s.m = (typename tuple <T0b,T1b,T2b,T3b,T4b>::very_long)m;
-			return s;
-		}
-	};
-
-	// Another way to access an element ...
-	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
-	inline typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
-			tuple<T0,T1,T2,T3,T4>& m)	{
-			return m.template get<N>();
-		}
-
-	// ... and the const version
-	template <unsigned N,typename T0,typename T1,typename T2,typename T3,typename T4>
-	inline const typename tuple<T0,T1,T2,T3,T4>::very_long::template type_getter<N>::type& get (
-			const tuple<T0,T1,T2,T3,T4>& m)	{
-			return m.template get<N>();
-		}
-
-	// Constructs a tuple with 5 elements
-	template <typename T0,typename T1,typename T2,typename T3,typename T4>
-	inline tuple <T0,T1,T2,T3,T4> make_tuple (const T0& t0,
-		const T1& t1,const T2& t2,const T3& t3,const T4& t4) {
-
-		tuple <T0,T1,T2,T3,T4> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		t.template get<2>() = t2;
-		t.template get<3>() = t3;
-		t.template get<4>() = t4;
-		return t;
-	}
-
-	// Constructs a tuple with 4 elements
-	template <typename T0,typename T1,typename T2,typename T3>
-	inline tuple <T0,T1,T2,T3> make_tuple (const T0& t0,
-		const T1& t1,const T2& t2,const T3& t3) {
-		tuple <T0,T1,T2,T3> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		t.template get<2>() = t2;
-		t.template get<3>() = t3;
-		return t;
-	}
-
-	// Constructs a tuple with 3 elements
-	template <typename T0,typename T1,typename T2>
-	inline tuple <T0,T1,T2> make_tuple (const T0& t0,
-		const T1& t1,const T2& t2) {
-		tuple <T0,T1,T2> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		t.template get<2>() = t2;
-		return t;
-	}
-
-	// Constructs a tuple with 2 elements 
-	template <typename T0,typename T1>
-	inline tuple <T0,T1> make_tuple (const T0& t0,
-		const T1& t1) {
-		tuple <T0,T1> t;
-		t.template get<0>() = t0;
-		t.template get<1>() = t1;
-		return t;
-	}
-
-	// Constructs a tuple with 1 elements (well ...)
-	template <typename T0>
-	inline tuple <T0> make_tuple (const T0& t0) {
-		tuple <T0> t;
-		t.template get<0>() = t0;
-		return t;
-	}
-
-	// Constructs a tuple with 0 elements (well ...)
-	inline tuple <> make_tuple () {
-		tuple <> t;
-		return t;
-	}
-}
-
-#endif // !! BOOST_TUPLE_INCLUDED

code/C4DImporter.cpp

@@ -131,7 +131,7 @@ void C4DImporter::SetupProperties(const Importer* /*pImp*/)
 void C4DImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
 
     if( file.get() == NULL) {
         ThrowException("failed to open file " + pFile);
@@ -161,7 +161,7 @@ void C4DImporter::InternReadFile( const std::string& pFile,
         RecurseHierarchy(doc->GetFirstObject(), pScene->mRootNode);
     }
     catch(...) {
-        BOOST_FOREACH(aiMesh* mesh, meshes) {
+        for(aiMesh* mesh : meshes) {
             delete mesh;
         }
         BaseDocument::Free(doc);
@@ -176,7 +176,7 @@ void C4DImporter::InternReadFile( const std::string& pFile,
 
     // copy materials over, adding a default material if necessary
     unsigned int mat_count = static_cast<unsigned int>(materials.size());
-    BOOST_FOREACH(aiMesh* mesh, meshes) {
+    for(aiMesh* mesh : meshes) {
         ai_assert(mesh->mMaterialIndex <= mat_count);
         if(mesh->mMaterialIndex >= mat_count) {
             ++mat_count;

code/CMakeLists.txt

@@ -1,3 +1,41 @@
+# Open Asset Import Library (assimp)
+# ----------------------------------------------------------------------
+#
+# Copyright (c) 2006-2016, 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.
+#
+#----------------------------------------------------------------------
+
 # Listing and grouping of all the source files.
 # 1) Set the file lists for each component
 # 2) Create a Source Group for each component, for IDE project orginization
@@ -61,20 +99,6 @@ SET( Core_SRCS
   Assimp.cpp
 )
 
-SET( Boost_SRCS
-  BoostWorkaround/boost/math/common_factor_rt.hpp
-  BoostWorkaround/boost/foreach.hpp
-  BoostWorkaround/boost/format.hpp
-  BoostWorkaround/boost/scoped_array.hpp
-  BoostWorkaround/boost/scoped_ptr.hpp
-  BoostWorkaround/boost/shared_array.hpp
-  BoostWorkaround/boost/shared_ptr.hpp
-  BoostWorkaround/boost/make_shared.hpp
-  BoostWorkaround/boost/static_assert.hpp
-  BoostWorkaround/boost/tuple/tuple.hpp
-)
-SOURCE_GROUP(Boost FILES ${Boost_SRCS})
-
 SET( Logging_SRCS
   ${HEADER_PATH}/DefaultLogger.hpp
   ${HEADER_PATH}/LogStream.hpp
@@ -422,6 +446,9 @@ ADD_ASSIMP_IMPORTER(IFC
   STEPFileEncoding.cpp
   STEPFileEncoding.h
 )
+if (MSVC AND ASSIMP_BUILD_IFC_IMPORTER)
+  set_source_files_properties(IFCReaderGen.cpp PROPERTIES COMPILE_FLAGS "/bigobj")
+endif (MSVC AND ASSIMP_BUILD_IFC_IMPORTER)
 
 ADD_ASSIMP_IMPORTER(XGL
   XGLLoader.cpp
@@ -446,6 +473,7 @@ ADD_ASSIMP_IMPORTER(FBX
   FBXDocument.cpp
   FBXProperties.h
   FBXProperties.cpp
+  FBXMeshGeometry.h
   FBXMeshGeometry.cpp
   FBXMaterial.cpp
   FBXModel.cpp
@@ -576,11 +604,21 @@ ADD_ASSIMP_IMPORTER(GLTF
 
   glTFImporter.cpp
   glTFImporter.h
-  
+
   glTFExporter.h
   glTFExporter.cpp
 )
 
+
+ADD_ASSIMP_IMPORTER(3MF
+    D3MFImporter.h
+    D3MFImporter.cpp
+    D3MFOpcPackage.h
+    D3MFOpcPackage.cpp
+
+)
+
+
 SET( Step_SRCS
   StepExporter.h
   StepExporter.cpp
@@ -710,13 +748,12 @@ SET( assimp_src
   ${Clipper_SRCS}
   ${openddl_parser_SRCS}
   # Necessary to show the headers in the project when using the VC++ generator:
-  ${Boost_SRCS}
 
   ${PUBLIC_HEADERS}
   ${COMPILER_HEADERS}
 
 )
-add_definitions( -DOPENDDLPARSER_BUILD )
+ADD_DEFINITIONS( -DOPENDDLPARSER_BUILD )
 
 INCLUDE_DIRECTORIES(
   ../contrib/openddlparser/include

code/COBLoader.cpp

@@ -53,8 +53,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "LineSplitter.h"
 #include "TinyFormatter.h"
-#include <boost/scoped_ptr.hpp>
-#include <boost/foreach.hpp>
+#include <memory>
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/scene.h"
@@ -64,8 +63,6 @@ using namespace Assimp;
 using namespace Assimp::COB;
 using namespace Assimp::Formatter;
 
-#define for_each BOOST_FOREACH
-
 
 static const float units[] = {
     1000.f,
@@ -144,7 +141,7 @@ void COBImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
     COB::Scene scene;
-    boost::scoped_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
+    std::unique_ptr<StreamReaderLE> stream(new StreamReaderLE( pIOHandler->Open(pFile,"rb")) );
 
     // check header
     char head[32];
@@ -170,17 +167,17 @@ void COBImporter::InternReadFile( const std::string& pFile,
     }
 
     // sort faces by material indices
-    for_each(boost::shared_ptr< Node >& n,scene.nodes) {
+    for(std::shared_ptr< Node >& n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
             Mesh& mesh = (Mesh&)(*n.get());
-            for_each(Face& f,mesh.faces) {
+            for(Face& f : mesh.faces) {
                 mesh.temp_map[f.material].push_back(&f);
             }
         }
     }
 
     // count meshes
-    for_each(boost::shared_ptr< Node >& n,scene.nodes) {
+    for(std::shared_ptr< Node >& n : scene.nodes) {
         if (n->type == Node::TYPE_MESH) {
             Mesh& mesh = (Mesh&)(*n.get());
             if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
@@ -193,7 +190,7 @@ void COBImporter::InternReadFile( const std::string& pFile,
     pScene->mNumMeshes = 0;
 
     // count lights and cameras
-    for_each(boost::shared_ptr< Node >& n,scene.nodes) {
+    for(std::shared_ptr< Node >& n : scene.nodes) {
         if (n->type == Node::TYPE_LIGHT) {
             ++pScene->mNumLights;
         }
@@ -211,7 +208,7 @@ void COBImporter::InternReadFile( const std::string& pFile,
     pScene->mNumLights = pScene->mNumCameras = 0;
 
     // resolve parents by their IDs and build the output graph
-    boost::scoped_ptr<Node> root(new Group());
+    std::unique_ptr<Node> root(new Group());
     for(size_t n = 0; n < scene.nodes.size(); ++n) {
         const Node& nn = *scene.nodes[n].get();
         if(nn.parent_id==0) {
@@ -230,7 +227,7 @@ void COBImporter::InternReadFile( const std::string& pFile,
 }
 
 // ------------------------------------------------------------------------------------------------
-void ConvertTexture(boost::shared_ptr< Texture > tex, aiMaterial* out, aiTextureType type)
+void ConvertTexture(std::shared_ptr< Texture > tex, aiMaterial* out, aiTextureType type)
 {
     const aiString path( tex->path );
     out->AddProperty(&path,AI_MATKEY_TEXTURE(type,0));
@@ -251,10 +248,10 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
         if (ndmesh.vertex_positions.size() && ndmesh.texture_coords.size()) {
 
             typedef std::pair<unsigned int,Mesh::FaceRefList> Entry;
-            for_each(const Entry& reflist,ndmesh.temp_map) {
+            for(const Entry& reflist : ndmesh.temp_map) {
                 {   // create mesh
                     size_t n = 0;
-                    for_each(Face* f, reflist.second) {
+                    for(Face* f : reflist.second) {
                         n += f->indices.size();
                     }
                     if (!n) {
@@ -267,7 +264,7 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
                     outmesh->mTextureCoords[0] = new aiVector3D[n];
 
                     outmesh->mFaces = new aiFace[reflist.second.size()]();
-                    for_each(Face* f, reflist.second) {
+                    for(Face* f : reflist.second) {
                         if (f->indices.empty()) {
                             continue;
                         }
@@ -275,7 +272,7 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
                         aiFace& fout = outmesh->mFaces[outmesh->mNumFaces++];
                         fout.mIndices = new unsigned int[f->indices.size()];
 
-                        for_each(VertexIndex& v, f->indices) {
+                        for(VertexIndex& v : f->indices) {
                             if (v.pos_idx >= ndmesh.vertex_positions.size()) {
                                 ThrowException("Position index out of range");
                             }
@@ -295,13 +292,13 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
                     outmesh->mMaterialIndex = fill->mNumMaterials;
                 }{  // create material
                     const Material* min = NULL;
-                    for_each(const Material& m, scin.materials) {
+                    for(const Material& m : scin.materials) {
                         if (m.parent_id == ndmesh.id && m.matnum == reflist.first) {
                             min = &m;
                             break;
                         }
                     }
-                    boost::scoped_ptr<const Material> defmat;
+                    std::unique_ptr<const Material> defmat;
                     if(!min) {
                         DefaultLogger::get()->debug(format()<<"Could not resolve material index "
                             <<reflist.first<<" - creating default material for this slot");
@@ -396,7 +393,7 @@ aiNode* COBImporter::BuildNodes(const Node& root,const Scene& scin,aiScene* fill
 
     // add children recursively
     nd->mChildren = new aiNode*[root.temp_children.size()]();
-    for_each(const Node* n, root.temp_children) {
+    for(const Node* n : root.temp_children) {
         (nd->mChildren[nd->mNumChildren++] = BuildNodes(*n,scin,fill))->mParent = nd;
     }
 
@@ -647,7 +644,7 @@ void COBImporter::ReadUnit_Ascii(Scene& out, LineSplitter& splitter, const Chunk
 
     // parent chunks preceede their childs, so we should have the
     // corresponding chunk already.
-    for_each(boost::shared_ptr< Node >& nd, out.nodes) {
+    for(std::shared_ptr< Node >& nd : out.nodes) {
         if (nd->id == nfo.parent_id) {
             const unsigned int t=strtoul10(splitter[1]);
 
@@ -676,7 +673,7 @@ void COBImporter::ReadLght_Ascii(Scene& out, LineSplitter& splitter, const Chunk
         return UnsupportedChunk_Ascii(splitter,nfo,"Lght");
     }
 
-    out.nodes.push_back(boost::shared_ptr<Light>(new Light()));
+    out.nodes.push_back(std::shared_ptr<Light>(new Light()));
     Light& msh = (Light&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -732,7 +729,7 @@ void COBImporter::ReadCame_Ascii(Scene& out, LineSplitter& splitter, const Chunk
         return UnsupportedChunk_Ascii(splitter,nfo,"Came");
     }
 
-    out.nodes.push_back(boost::shared_ptr<Camera>(new Camera()));
+    out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
     Camera& msh = (Camera&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -750,7 +747,7 @@ void COBImporter::ReadBone_Ascii(Scene& out, LineSplitter& splitter, const Chunk
         return UnsupportedChunk_Ascii(splitter,nfo,"Bone");
     }
 
-    out.nodes.push_back(boost::shared_ptr<Bone>(new Bone()));
+    out.nodes.push_back(std::shared_ptr<Bone>(new Bone()));
     Bone& msh = (Bone&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -766,7 +763,7 @@ void COBImporter::ReadGrou_Ascii(Scene& out, LineSplitter& splitter, const Chunk
         return UnsupportedChunk_Ascii(splitter,nfo,"Grou");
     }
 
-    out.nodes.push_back(boost::shared_ptr<Group>(new Group()));
+    out.nodes.push_back(std::shared_ptr<Group>(new Group()));
     Group& msh = (Group&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -780,7 +777,7 @@ void COBImporter::ReadPolH_Ascii(Scene& out, LineSplitter& splitter, const Chunk
         return UnsupportedChunk_Ascii(splitter,nfo,"PolH");
     }
 
-    out.nodes.push_back(boost::shared_ptr<Mesh>(new Mesh()));
+    out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
     Mesh& msh = (Mesh&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -903,7 +900,7 @@ void COBImporter::ReadBitM_Ascii(Scene& /*out*/, LineSplitter& splitter, const C
 void COBImporter::ReadString_Binary(std::string& out, StreamReaderLE& reader)
 {
     out.resize( reader.GetI2());
-    for_each(char& c,out) {
+    for(char& c : out) {
         c = reader.GetI1();
     }
 }
@@ -1036,21 +1033,21 @@ void COBImporter::ReadPolH_Binary(COB::Scene& out, StreamReaderLE& reader, const
     }
     const chunk_guard cn(nfo,reader);
 
-    out.nodes.push_back(boost::shared_ptr<Mesh>(new Mesh()));
+    out.nodes.push_back(std::shared_ptr<Mesh>(new Mesh()));
     Mesh& msh = (Mesh&)(*out.nodes.back().get());
     msh = nfo;
 
     ReadBasicNodeInfo_Binary(msh,reader,nfo);
 
     msh.vertex_positions.resize(reader.GetI4());
-    for_each(aiVector3D& v,msh.vertex_positions) {
+    for(aiVector3D& v : msh.vertex_positions) {
         v.x = reader.GetF4();
         v.y = reader.GetF4();
         v.z = reader.GetF4();
     }
 
     msh.texture_coords.resize(reader.GetI4());
-    for_each(aiVector2D& v,msh.texture_coords) {
+    for(aiVector2D& v : msh.texture_coords) {
         v.x = reader.GetF4();
         v.y = reader.GetF4();
     }
@@ -1226,7 +1223,7 @@ void COBImporter::ReadCame_Binary(COB::Scene& out, StreamReaderLE& reader, const
 
     const chunk_guard cn(nfo,reader);
 
-    out.nodes.push_back(boost::shared_ptr<Camera>(new Camera()));
+    out.nodes.push_back(std::shared_ptr<Camera>(new Camera()));
     Camera& msh = (Camera&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -1249,7 +1246,7 @@ void COBImporter::ReadLght_Binary(COB::Scene& out, StreamReaderLE& reader, const
 
     const chunk_guard cn(nfo,reader);
 
-    out.nodes.push_back(boost::shared_ptr<Light>(new Light()));
+    out.nodes.push_back(std::shared_ptr<Light>(new Light()));
     Light& msh = (Light&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -1265,7 +1262,7 @@ void COBImporter::ReadGrou_Binary(COB::Scene& out, StreamReaderLE& reader, const
 
     const chunk_guard cn(nfo,reader);
 
-    out.nodes.push_back(boost::shared_ptr<Group>(new Group()));
+    out.nodes.push_back(std::shared_ptr<Group>(new Group()));
     Group& msh = (Group&)(*out.nodes.back().get());
     msh = nfo;
 
@@ -1283,7 +1280,7 @@ void COBImporter::ReadUnit_Binary(COB::Scene& out, StreamReaderLE& reader, const
 
     // parent chunks preceede their childs, so we should have the
     // corresponding chunk already.
-    for_each(boost::shared_ptr< Node >& nd, out.nodes) {
+    for(std::shared_ptr< Node >& nd : out.nodes) {
         if (nd->id == nfo.parent_id) {
             const unsigned int t=reader.GetI2();
             nd->unit_scale = t>=sizeof(units)/sizeof(units[0])?(

code/COBScene.h

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_COB_SCENE_H
 #define INCLUDED_AI_COB_SCENE_H
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include <deque>
 
 #include "BaseImporter.h"
@@ -237,7 +237,7 @@ struct Material : ChunkInfo
     AutoFacet autofacet;
     float autofacet_angle;
 
-    boost::shared_ptr<Texture> tex_env,tex_bump,tex_color;
+    std::shared_ptr<Texture> tex_env,tex_bump,tex_color;
 };
 
 // ------------------
@@ -254,7 +254,7 @@ struct Bitmap : ChunkInfo
     std::vector<char> buff_zipped;
 };
 
-typedef std::deque< boost::shared_ptr<Node> > NodeList;
+typedef std::deque< std::shared_ptr<Node> > NodeList;
 typedef std::vector< Material > MaterialList;
 
 // ------------------

code/CSMLoader.cpp

@@ -52,7 +52,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "ParsingUtils.h"
 #include "fast_atof.h"
 #include "../include/assimp/Importer.hpp"
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/anim.h"
 #include "../include/assimp/DefaultLogger.hpp"
@@ -122,7 +122,7 @@ void CSMImporter::SetupProperties(const Importer* pImp)
 void CSMImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile, "rb"));
 
     // Check whether we can read from the file
     if( file.get() == NULL) {
@@ -227,7 +227,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
 
                         // read x,y,z
                         if(!SkipSpacesAndLineEnd(&buffer))
-                            throw DeadlyImportError("CSM: Unexpected EOF occured reading sample x coord");
+                            throw DeadlyImportError("CSM: Unexpected EOF occurred reading sample x coord");
 
                         if (TokenMatchI(buffer, "DROPOUT", 7))  {
                             // seems this is invalid marker data; at least the doc says it's possible
@@ -239,11 +239,11 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                             buffer = fast_atoreal_move<float>(buffer, (float&)sub->mValue.x);
 
                             if(!SkipSpacesAndLineEnd(&buffer))
-                                throw DeadlyImportError("CSM: Unexpected EOF occured reading sample y coord");
+                                throw DeadlyImportError("CSM: Unexpected EOF occurred reading sample y coord");
                             buffer = fast_atoreal_move<float>(buffer, (float&)sub->mValue.y);
 
                             if(!SkipSpacesAndLineEnd(&buffer))
-                                throw DeadlyImportError("CSM: Unexpected EOF occured reading sample z coord");
+                                throw DeadlyImportError("CSM: Unexpected EOF occurred reading sample z coord");
                             buffer = fast_atoreal_move<float>(buffer, (float&)sub->mValue.z);
 
                             ++s->mNumPositionKeys;

code/CalcTangentsProcess.cpp

@@ -108,7 +108,7 @@ void CalcTangentsProcess::Execute( aiScene* pScene)
 }
 
 // ------------------------------------------------------------------------------------------------
-// Calculates tangents and bitangents for the given mesh
+// Calculates tangents and bi-tangents for the given mesh
 bool CalcTangentsProcess::ProcessMesh( aiMesh* pMesh, unsigned int meshIndex)
 {
     // we assume that the mesh is still in the verbose vertex format where each face has its own set

code/ColladaExporter.cpp

@@ -55,7 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Exceptional.h"
 
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 #include <ctime>
 #include <set>
 
@@ -75,7 +75,7 @@ void ExportSceneCollada(const char* pFile, IOSystem* pIOSystem, const aiScene* p
     ColladaExporter iDoTheExportThing( pScene, pIOSystem, path, file);
 
     // we're still here - export successfully completed. Write result to the given IOSYstem
-    boost::scoped_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
+    std::unique_ptr<IOStream> outfile (pIOSystem->Open(pFile,"wt"));
     if(outfile == NULL) {
         throw DeadlyExportError("could not open output .dae file: " + std::string(pFile));
     }
@@ -268,7 +268,7 @@ void ColladaExporter::WriteTextures() {
 
             std::string name = mFile + "_texture_" + (i < 1000 ? "0" : "") + (i < 100 ? "0" : "") + (i < 10 ? "0" : "") + str + "." + ((const char*) texture->achFormatHint);
 
-            boost::scoped_ptr<IOStream> outfile(mIOSystem->Open(mPath + name, "wb"));
+            std::unique_ptr<IOStream> outfile(mIOSystem->Open(mPath + name, "wb"));
             if(outfile == NULL) {
                 throw DeadlyExportError("could not open output texture file: " + mPath + name);
             }
@@ -636,7 +636,7 @@ void ColladaExporter::WriteMaterials()
     aiString name;
     if( mat->Get( AI_MATKEY_NAME, name) != aiReturn_SUCCESS )
       name = "mat";
-    materials[a].name = std::string( "m") + boost::lexical_cast<std::string> (a) + name.C_Str();
+    materials[a].name = std::string( "m") + std::to_string(a) + name.C_Str();
     for( std::string::iterator it = materials[a].name.begin(); it != materials[a].name.end(); ++it ) {
       if( !isalnum_C( *it ) ) {
         *it = '_';
@@ -812,7 +812,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     {
         if( mesh->HasTextureCoords( a) )
         {
-            WriteFloatArray( idstr + "-tex" + boost::lexical_cast<std::string> (a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
+            WriteFloatArray( idstr + "-tex" + std::to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
                 (float*) mesh->mTextureCoords[a], mesh->mNumVertices);
         }
     }
@@ -821,7 +821,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
     {
         if( mesh->HasVertexColors( a) )
-            WriteFloatArray( idstr + "-color" + boost::lexical_cast<std::string> (a), FloatType_Color, (float*) mesh->mColors[a], mesh->mNumVertices);
+            WriteFloatArray( idstr + "-color" + std::to_string(a), FloatType_Color, (float*) mesh->mColors[a], mesh->mNumVertices);
     }
 
     // assemble vertex structure
@@ -872,7 +872,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
         mOutput << startstr << "</lines>" << endstr;
     }
 
-    // triangle - dont use it, because compatibility problems
+    // triangle - don't use it, because compatibility problems
 
     // polygons
     if (countPoly)
@@ -1041,7 +1041,7 @@ void ColladaExporter::WriteNode(aiNode* pNode)
     PushTag();
 
     // write transformation - we can directly put the matrix there
-    // TODO: (thom) decompose into scale - rot - quad to allow adressing it by animations afterwards
+    // TODO: (thom) decompose into scale - rot - quad to allow addressing it by animations afterwards
     const aiMatrix4x4& mat = pNode->mTransformation;
     mOutput << startstr << "<matrix>";
     mOutput << mat.a1 << " " << mat.a2 << " " << mat.a3 << " " << mat.a4 << " ";

code/ColladaExporter.h

@@ -52,7 +52,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <sstream>
 #include <vector>
 #include <map>
-#include <boost/lexical_cast.hpp>
 
 struct aiScene;
 struct aiNode;
@@ -123,7 +122,7 @@ protected:
     void PopTag() { ai_assert( startstr.length() > 1); startstr.erase( startstr.length() - 2); }
 
     /// Creates a mesh ID for the given mesh
-    std::string GetMeshId( size_t pIndex) const { return std::string( "meshId" ) + boost::lexical_cast<std::string> (pIndex); }
+    std::string GetMeshId( size_t pIndex) const { return std::string( "meshId" ) + std::to_string(pIndex); }
 
 public:
     /// Stringstream to write all output into

code/ColladaLoader.cpp

@@ -56,7 +56,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "time.h"
 #include "math.h"
-#include <boost/foreach.hpp>
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/Importer.hpp"
 #include <numeric>
@@ -64,6 +63,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 using namespace Assimp;
+using namespace Assimp::Formatter;
 
 static const aiImporterDesc desc = {
     "Collada Importer",
@@ -317,7 +317,7 @@ void ColladaLoader::ApplyVertexToEffectSemanticMapping(Collada::Sampler& sampler
 // Builds lights for the given node and references them
 void ColladaLoader::BuildLightsForNode( const ColladaParser& pParser, const Collada::Node* pNode, aiNode* pTarget)
 {
-    BOOST_FOREACH( const Collada::LightInstance& lid, pNode->mLights)
+    for( const Collada::LightInstance& lid : pNode->mLights)
     {
         // find the referred light
         ColladaParser::LightLibrary::const_iterator srcLightIt = pParser.mLightLibrary.find( lid.mLight);
@@ -385,7 +385,7 @@ void ColladaLoader::BuildLightsForNode( const ColladaParser& pParser, const Coll
 // Builds cameras for the given node and references them
 void ColladaLoader::BuildCamerasForNode( const ColladaParser& pParser, const Collada::Node* pNode, aiNode* pTarget)
 {
-    BOOST_FOREACH( const Collada::CameraInstance& cid, pNode->mCameras)
+    for( const Collada::CameraInstance& cid : pNode->mCameras)
     {
         // find the referred light
         ColladaParser::CameraLibrary::const_iterator srcCameraIt = pParser.mCameraLibrary.find( cid.mCamera);
@@ -447,7 +447,7 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
     newMeshRefs.reserve(pNode->mMeshes.size());
 
     // add a mesh for each subgroup in each collada mesh
-    BOOST_FOREACH( const Collada::MeshInstance& mid, pNode->mMeshes)
+    for( const Collada::MeshInstance& mid : pNode->mMeshes)
     {
         const Collada::Mesh* srcMesh = NULL;
         const Collada::Controller* srcController = NULL;
@@ -468,7 +468,7 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
 
             if( !srcMesh)
             {
-                DefaultLogger::get()->warn( boost::str( boost::format( "Collada: Unable to find geometry for ID \"%s\". Skipping.") % mid.mMeshOrController));
+                DefaultLogger::get()->warn( format() << "Collada: Unable to find geometry for ID \"" << mid.mMeshOrController << "\". Skipping." );
                 continue;
             }
         } else
@@ -497,7 +497,7 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
             }
             else
             {
-                DefaultLogger::get()->warn( boost::str( boost::format( "Collada: No material specified for subgroup <%s> in geometry <%s>.") % submesh.mMaterial % mid.mMeshOrController));
+                DefaultLogger::get()->warn( format() << "Collada: No material specified for subgroup <" << submesh.mMaterial << "> in geometry <" << mid.mMeshOrController << ">." );
                 if( !mid.mMaterials.empty() )
                     meshMaterial = mid.mMaterials.begin()->second.mMatName;
             }
@@ -663,7 +663,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
         // joint vertex_weight name list - should refer to the same list as the joint names above. If not, report and reconsider
         const Collada::Accessor& weightNamesAcc = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, pSrcController->mWeightInputJoints.mAccessor);
         if( &weightNamesAcc != &jointNamesAcc)
-            throw DeadlyImportError( "Temporary implementational lazyness. If you read this, please report to the author.");
+            throw DeadlyImportError( "Temporary implementational laziness. If you read this, please report to the author.");
         // vertex weights
         const Collada::Accessor& weightsAcc = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, pSrcController->mWeightInputWeights.mAccessor);
         const Collada::Data& weights = pParser.ResolveLibraryReference( pParser.mDataLibrary, weightsAcc.mSource);
@@ -785,7 +785,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
             if( bnode)
                 bone->mName.Set( FindNameForNode( bnode));
             else
-                DefaultLogger::get()->warn( boost::str( boost::format( "ColladaLoader::CreateMesh(): could not find corresponding node for joint \"%s\".") % bone->mName.data));
+                DefaultLogger::get()->warn( format() << "ColladaLoader::CreateMesh(): could not find corresponding node for joint \"" << bone->mName.data << "\"." );
 
             // and insert bone
             dstMesh->mBones[boneCount++] = bone;
@@ -1005,7 +1005,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
                 else if( subElement == "Z")
                     entry.mSubElement = 2;
                 else
-                    DefaultLogger::get()->warn( boost::str( boost::format( "Unknown anim subelement <%s>. Ignoring") % subElement));
+                    DefaultLogger::get()->warn( format() << "Unknown anim subelement <" << subElement << ">. Ignoring" );
             } else
             {
                 // no subelement following, transformId is remaining string
@@ -1083,7 +1083,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
 
             // time count and value count must match
             if( e.mTimeAccessor->mCount != e.mValueAccessor->mCount)
-                throw DeadlyImportError( boost::str( boost::format( "Time count / value count mismatch in animation channel \"%s\".") % e.mChannel->mTarget));
+                throw DeadlyImportError( format() << "Time count / value count mismatch in animation channel \"" << e.mChannel->mTarget << "\"." );
 
       if( e.mTimeAccessor->mCount > 0 )
       {
@@ -1148,7 +1148,7 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
               // Calculate resulting transformation
               aiMatrix4x4 mat = pParser.CalculateResultTransform( transforms);
 
-              // out of lazyness: we store the time in matrix.d4
+              // out of laziness: we store the time in matrix.d4
               mat.d4 = time;
               resultTrafos.push_back( mat);
 
@@ -1156,13 +1156,13 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
               float nextTime = 1e20f;
               for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
               {
-                  Collada::ChannelEntry& e = *it;
+                  Collada::ChannelEntry& channelElement = *it;
 
                   // find the next time value larger than the current
                   size_t pos = 0;
-                  while( pos < e.mTimeAccessor->mCount)
+                  while( pos < channelElement.mTimeAccessor->mCount)
                   {
-                      float t = ReadFloat( *e.mTimeAccessor, *e.mTimeData, pos, 0);
+                      const float t = ReadFloat( *channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
                       if( t > time)
                       {
                           nextTime = std::min( nextTime, t);
@@ -1170,21 +1170,21 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
                       }
                       ++pos;
                   }
-				  
+
 				  // https://github.com/assimp/assimp/issues/458
 			  	  // Sub-sample axis-angle channels if the delta between two consecutive
                   // key-frame angles is >= 180 degrees.
-				  if (transforms[e.mTransformIndex].mType == Collada::TF_ROTATE && e.mSubElement == 3 && pos > 0 && pos < e.mTimeAccessor->mCount) {
-					  float cur_key_angle = ReadFloat(*e.mValueAccessor, *e.mValueData, pos, 0);
-					  float last_key_angle = ReadFloat(*e.mValueAccessor, *e.mValueData, pos - 1, 0);
-					  float cur_key_time = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos, 0);
-					  float last_key_time = ReadFloat(*e.mTimeAccessor, *e.mTimeData, pos - 1, 0);
-					  float last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time); 
-					  float delta = std::fabs(cur_key_angle - last_eval_angle);
+				  if (transforms[channelElement.mTransformIndex].mType == Collada::TF_ROTATE && channelElement.mSubElement == 3 && pos > 0 && pos < channelElement.mTimeAccessor->mCount) {
+					  const float cur_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos, 0);
+                      const float last_key_angle = ReadFloat(*channelElement.mValueAccessor, *channelElement.mValueData, pos - 1, 0);
+                      const float cur_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos, 0);
+                      const float last_key_time = ReadFloat(*channelElement.mTimeAccessor, *channelElement.mTimeData, pos - 1, 0);
+                      const float last_eval_angle = last_key_angle + (cur_key_angle - last_key_angle) * (time - last_key_time) / (cur_key_time - last_key_time);
+                      const float delta = std::fabs(cur_key_angle - last_eval_angle);
 				      if (delta >= 180.0f) {
-						int subSampleCount = static_cast<int>(floorf(delta / 90.0f));
+						const int subSampleCount = static_cast<int>(floorf(delta / 90.0f));
 						if (cur_key_time != time) {
-							float nextSampleTime = time + (cur_key_time - time) / subSampleCount;
+							const float nextSampleTime = time + (cur_key_time - time) / subSampleCount;
 							nextTime = std::min(nextTime, nextSampleTime);
 						  }
 					  }
@@ -1294,7 +1294,7 @@ void ColladaLoader::AddTexture ( aiMaterial& mat, const ColladaParser& pParser,
         _AI_MATKEY_TEXBLEND_BASE, type, idx);
 
     // UV source index ... if we didn't resolve the mapping, it is actually just
-    // a guess but it works in most cases. We search for the frst occurence of a
+    // a guess but it works in most cases. We search for the frst occurrence of a
     // number in the channel name. We assume it is the zero-based index into the
     // UV channel array of all corresponding meshes. It could also be one-based
     // for some exporters, but we won't care of it unless someone complains about.
@@ -1499,8 +1499,8 @@ aiString ColladaLoader::FindFilenameForEffectTexture( const ColladaParser& pPars
     ColladaParser::ImageLibrary::const_iterator imIt = pParser.mImageLibrary.find( name);
     if( imIt == pParser.mImageLibrary.end())
     {
-        throw DeadlyImportError( boost::str( boost::format(
-            "Collada: Unable to resolve effect texture entry \"%s\", ended up at ID \"%s\".") % pName % name));
+        throw DeadlyImportError( format() <<
+            "Collada: Unable to resolve effect texture entry \"" << pName << "\", ended up at ID \"" << name << "\"." );
     }
 
     aiString result;
@@ -1666,7 +1666,7 @@ std::string ColladaLoader::FindNameForNode( const Collada::Node* pNode)
     {
         // No need to worry. Unnamed nodes are no problem at all, except
         // if cameras or lights need to be assigned to them.
-    return boost::str( boost::format( "$ColladaAutoName$_%d") % mNodeNameCounter++);
+    return format() << "$ColladaAutoName$_" << mNodeNameCounter++;
     }
 }
 

code/ColladaParser.cpp

@@ -51,15 +51,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "ColladaParser.h"
 #include "fast_atof.h"
 #include "ParsingUtils.h"
-#include <boost/scoped_ptr.hpp>
-#include <boost/foreach.hpp>
+#include <memory>
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/light.h"
+#include "TinyFormatter.h"
 
 
 using namespace Assimp;
 using namespace Assimp::Collada;
+using namespace Assimp::Formatter;
 
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
@@ -88,13 +89,13 @@ ColladaParser::ColladaParser( IOSystem* pIOHandler, const std::string& pFile)
     }
 
     // open the file
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open(pFile ) );
+    std::unique_ptr<IOStream> file( pIOHandler->Open(pFile ) );
     if (file.get() == NULL) {
         throw DeadlyImportError( "Failed to open file " + pFile + "." );
     }
 
     // generate a XML reader for it
-    boost::scoped_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
+    std::unique_ptr<CIrrXML_IOStreamReader> mIOWrapper(new CIrrXML_IOStreamReader(file.get()));
     mReader = irr::io::createIrrXMLReader( mIOWrapper.get());
     if (!mReader) {
         ThrowException("Collada: Unable to open file.");
@@ -164,7 +165,7 @@ void ColladaParser::ReadContents()
                 ReadStructure();
             } else
             {
-                DefaultLogger::get()->debug( boost::str( boost::format( "Ignoring global element <%s>.") % mReader->getNodeName()));
+                DefaultLogger::get()->debug( format() << "Ignoring global element <" << mReader->getNodeName() << ">." );
                 SkipElement();
             }
         } else
@@ -297,7 +298,7 @@ void ColladaParser::ReadAnimationClipLibrary()
 				else if (indexID >= 0)
 					animName = mReader->getAttributeValue(indexID);
 				else
-					animName = "animation_" + mAnimationClipLibrary.size();
+					animName = std::string("animation_") + std::to_string(mAnimationClipLibrary.size());
 
 				std::pair<std::string, std::vector<std::string> > clip;
 
@@ -529,10 +530,10 @@ void ColladaParser::ReadAnimation( Collada::Animation* pParent)
     // it turned out to have channels - add them
     if( !channels.empty())
     {
-		// FIXME: Is this essentially doing the same as "single-anim-node" codepath in 
+		// FIXME: Is this essentially doing the same as "single-anim-node" codepath in
 		//        ColladaLoader::StoreAnimations? For now, this has been deferred to after
-		//        all animations and all clips have been read. Due to handling of 
-		//        <library_animation_clips> this cannot be done here, as the channel owner 
+		//        all animations and all clips have been read. Due to handling of
+		//        <library_animation_clips> this cannot be done here, as the channel owner
 		//        is lost, and some exporters make up animations by referring to multiple
 		//        single-channel animations from an <instance_animation>.
 /*
@@ -616,7 +617,7 @@ void ColladaParser::ReadControllerLibrary()
         {
             if( IsElement( "controller"))
             {
-                // read ID. Ask the spec if it's neccessary or optional... you might be surprised.
+                // read ID. Ask the spec if it's necessary or optional... you might be surprised.
                 int attrID = GetAttribute( "id");
                 std::string id = mReader->getAttributeValue( attrID);
 
@@ -725,7 +726,7 @@ void ColladaParser::ReadControllerJoints( Collada::Controller& pController)
 
                 // local URLS always start with a '#'. We don't support global URLs
                 if( attrSource[0] != '#')
-                    ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <joints> data <input> element") % attrSource));
+                    ThrowException( format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <joints> data <input> element" );
                 attrSource++;
 
                 // parse source URL to corresponding source
@@ -734,7 +735,7 @@ void ColladaParser::ReadControllerJoints( Collada::Controller& pController)
                 else if( strcmp( attrSemantic, "INV_BIND_MATRIX") == 0)
                     pController.mJointOffsetMatrixSource = attrSource;
                 else
-                    ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <joints> data <input> element") % attrSemantic));
+                    ThrowException( format() << "Unknown semantic \"" << attrSemantic << "\" in <joints> data <input> element" );
 
                 // skip inner data, if present
                 if( !mReader->isEmptyElement())
@@ -784,7 +785,7 @@ void ColladaParser::ReadControllerWeights( Collada::Controller& pController)
 
                 // local URLS always start with a '#'. We don't support global URLs
                 if( attrSource[0] != '#')
-                    ThrowException( boost::str( boost::format( "Unsupported URL format in \"%s\" in source attribute of <vertex_weights> data <input> element") % attrSource));
+                    ThrowException( format() << "Unsupported URL format in \"" << attrSource << "\" in source attribute of <vertex_weights> data <input> element" );
                 channel.mAccessor = attrSource + 1;
 
                 // parse source URL to corresponding source
@@ -793,7 +794,7 @@ void ColladaParser::ReadControllerWeights( Collada::Controller& pController)
                 else if( strcmp( attrSemantic, "WEIGHT") == 0)
                     pController.mWeightInputWeights = channel;
                 else
-                    ThrowException( boost::str( boost::format( "Unknown semantic \"%s\" in <vertex_weights> data <input> element") % attrSemantic));
+                    ThrowException( format() << "Unknown semantic \"" << attrSemantic << "\" in <vertex_weights> data <input> element" );
 
                 // skip inner data, if present
                 if( !mReader->isEmptyElement())
@@ -1404,7 +1405,7 @@ void ColladaParser::ReadEffectProfileCommon( Collada::Effect& pEffect)
                 pEffect.mHasTransparency = true;
 
                 const char* opaque = mReader->getAttributeValueSafe("opaque");
- 
+
                 if(::strcmp(opaque, "RGB_ZERO") == 0 || ::strcmp(opaque, "RGB_ONE") == 0) {
                     pEffect.mRGBTransparency = true;
                 }
@@ -1963,7 +1964,7 @@ void ColladaParser::ReadAccessor( const std::string& pID)
     int attrSource = GetAttribute( "source");
     const char* source = mReader->getAttributeValue( attrSource);
     if( source[0] != '#')
-        ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <accessor> element.") % source));
+        ThrowException( format() << "Unknown reference format in url \"" << source << "\" in source attribute of <accessor> element." );
     int attrCount = GetAttribute( "count");
     unsigned int count = (unsigned int) mReader->getAttributeValueAsInt( attrCount);
     int attrOffset = TestAttribute( "offset");
@@ -2022,7 +2023,7 @@ void ColladaParser::ReadAccessor( const std::string& pID)
                     else if( name == "U") acc.mSubOffset[0] = acc.mParams.size();
                     else if( name == "V") acc.mSubOffset[1] = acc.mParams.size();
                     //else
-                    //  DefaultLogger::get()->warn( boost::str( boost::format( "Unknown accessor parameter \"%s\". Ignoring data channel.") % name));
+                    //  DefaultLogger::get()->warn( format() << "Unknown accessor parameter \"" << name << "\". Ignoring data channel." );
                 }
 
                 // read data type
@@ -2045,7 +2046,7 @@ void ColladaParser::ReadAccessor( const std::string& pID)
                 SkipElement();
             } else
             {
-                ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <accessor>") % mReader->getNodeName()));
+                ThrowException( format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <accessor>" );
             }
         }
         else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
@@ -2075,7 +2076,7 @@ void ColladaParser::ReadVertexData( Mesh* pMesh)
                 ReadInputChannel( pMesh->mPerVertexData);
             } else
             {
-                ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <vertices>") % mReader->getNodeName()));
+                ThrowException( format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <vertices>" );
             }
         }
         else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
@@ -2173,13 +2174,13 @@ void ColladaParser::ReadIndexData( Mesh* pMesh)
                 SkipElement("extra");
             } else
             {
-                ThrowException( boost::str( boost::format( "Unexpected sub element <%s> in tag <%s>") % mReader->getNodeName() % elementName));
+                ThrowException( format() << "Unexpected sub element <" << mReader->getNodeName() << "> in tag <" << elementName << ">" );
             }
         }
         else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END)
         {
             if( mReader->getNodeName() != elementName)
-                ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % elementName));
+                ThrowException( format() << "Expected end of <" << elementName << "> element." );
 
             break;
         }
@@ -2212,7 +2213,7 @@ void ColladaParser::ReadInputChannel( std::vector<InputChannel>& poChannels)
     int attrSource = GetAttribute( "source");
     const char* source = mReader->getAttributeValue( attrSource);
     if( source[0] != '#')
-        ThrowException( boost::str( boost::format( "Unknown reference format in url \"%s\" in source attribute of <input> element.") % source));
+        ThrowException( format() << "Unknown reference format in url \"" << source << "\" in source attribute of <input> element." );
     channel.mAccessor = source+1; // skipping the leading #, hopefully the remaining text is the accessor ID only
 
     // read index offset, if per-index <input>
@@ -2226,7 +2227,7 @@ void ColladaParser::ReadInputChannel( std::vector<InputChannel>& poChannels)
         if(attrSet > -1){
             attrSet = mReader->getAttributeValueAsInt( attrSet);
             if(attrSet < 0)
-                ThrowException( boost::str( boost::format( "Invalid index \"%i\" in set attribute of <input> element") % (attrSet)));
+                ThrowException( format() << "Invalid index \"" << (attrSet) << "\" in set attribute of <input> element" );
 
             channel.mIndex = attrSet;
         }
@@ -2249,7 +2250,7 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
     // find the offset index for all per-vertex channels
     size_t numOffsets = 1;
     size_t perVertexOffset = SIZE_MAX; // invalid value
-    BOOST_FOREACH( const InputChannel& channel, pPerIndexChannels)
+    for( const InputChannel& channel : pPerIndexChannels)
     {
         numOffsets = std::max( numOffsets, channel.mOffset+1);
         if( channel.mType == IT_Vertex)
@@ -2262,7 +2263,7 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
     {
         case Prim_Polylist:
         {
-            BOOST_FOREACH( size_t i, pVCount)
+            for( size_t i : pVCount)
                 expectedPointCount += i;
             break;
         }
@@ -2282,7 +2283,7 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
     if( expectedPointCount > 0)
         indices.reserve( expectedPointCount * numOffsets);
 
-    if (pNumPrimitives > 0) // It is possible to not contain any indicies
+    if (pNumPrimitives > 0) // It is possible to not contain any indices
     {
         const char* content = GetTextContent();
         while( *content != 0)
@@ -2317,7 +2318,7 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
 
         // find accessor
         input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
-        // resolve accessor's data pointer as well, if neccessary
+        // resolve accessor's data pointer as well, if necessary
         const Accessor* acc = input.mResolved;
         if( !acc->mData)
             acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
@@ -2340,7 +2341,7 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
 
         // find accessor
         input.mResolved = &ResolveLibraryReference( mAccessorLibrary, input.mAccessor);
-        // resolve accessor's data pointer as well, if neccessary
+        // resolve accessor's data pointer as well, if necessary
         const Accessor* acc = input.mResolved;
         if( !acc->mData)
             acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
@@ -2450,7 +2451,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
 
     const Accessor& acc = *pInput.mResolved;
     if( pLocalIndex >= acc.mCount)
-        ThrowException( boost::str( boost::format( "Invalid data index (%d/%d) in primitive specification") % pLocalIndex % acc.mCount));
+        ThrowException( format() << "Invalid data index (" << pLocalIndex << "/" << acc.mCount << ") in primitive specification" );
 
     // get a pointer to the start of the data object referred to by the accessor and the local index
     const float* dataObject = &(acc.mData->mValues[0]) + acc.mOffset + pLocalIndex* acc.mStride;
@@ -2876,7 +2877,7 @@ void ColladaParser::ReadScene()
         if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
             if( IsElement( "instance_visual_scene"))
             {
-                // should be the first and only occurence
+                // should be the first and only occurrence
                 if( mRootNode)
                     ThrowException( "Invalid scene containing multiple root nodes in <instance_visual_scene> element");
 
@@ -2905,19 +2906,19 @@ void ColladaParser::ReadScene()
 // Aborts the file reading with an exception
 AI_WONT_RETURN void ColladaParser::ThrowException( const std::string& pError) const
 {
-    throw DeadlyImportError( boost::str( boost::format( "Collada: %s - %s") % mFileName % pError));
+    throw DeadlyImportError( format() << "Collada: " << mFileName << " - " << pError );
 }
 void ColladaParser::ReportWarning(const char* msg,...)
 {
     ai_assert(NULL != msg);
-    
+
     va_list args;
     va_start(args,msg);
-    
+
     char szBuffer[3000];
     const int iLen = vsprintf(szBuffer,msg,args);
     ai_assert(iLen > 0);
-    
+
     va_end(args);
     DefaultLogger::get()->warn("Validation warning: " + std::string(szBuffer,iLen));
 }
@@ -2956,14 +2957,14 @@ void ColladaParser::TestOpening( const char* pName)
 {
     // read element start
     if( !mReader->read())
-        ThrowException( boost::str( boost::format( "Unexpected end of file while beginning of <%s> element.") % pName));
+        ThrowException( format() << "Unexpected end of file while beginning of <" << pName << "> element." );
     // whitespace in front is ok, just read again if found
     if( mReader->getNodeType() == irr::io::EXN_TEXT)
         if( !mReader->read())
-            ThrowException( boost::str( boost::format( "Unexpected end of file while reading beginning of <%s> element.") % pName));
+            ThrowException( format() << "Unexpected end of file while reading beginning of <" << pName << "> element." );
 
     if( mReader->getNodeType() != irr::io::EXN_ELEMENT || strcmp( mReader->getNodeName(), pName) != 0)
-        ThrowException( boost::str( boost::format( "Expected start of <%s> element.") % pName));
+        ThrowException( format() << "Expected start of <" << pName << "> element." );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -2976,15 +2977,15 @@ void ColladaParser::TestClosing( const char* pName)
 
     // if not, read some more
     if( !mReader->read())
-        ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
+        ThrowException( format() << "Unexpected end of file while reading end of <" << pName << "> element." );
     // whitespace in front is ok, just read again if found
     if( mReader->getNodeType() == irr::io::EXN_TEXT)
         if( !mReader->read())
-            ThrowException( boost::str( boost::format( "Unexpected end of file while reading end of <%s> element.") % pName));
+            ThrowException( format() << "Unexpected end of file while reading end of <" << pName << "> element." );
 
     // but this has the be the closing tag, or we're lost
     if( mReader->getNodeType() != irr::io::EXN_ELEMENT_END || strcmp( mReader->getNodeName(), pName) != 0)
-        ThrowException( boost::str( boost::format( "Expected end of <%s> element.") % pName));
+        ThrowException( format() << "Expected end of <" << pName << "> element." );
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -2996,7 +2997,7 @@ int ColladaParser::GetAttribute( const char* pAttr) const
         return index;
 
     // attribute not found -> throw an exception
-    ThrowException( boost::str( boost::format( "Expected attribute \"%s\" for element <%s>.") % pAttr % mReader->getNodeName()));
+    ThrowException( format() << "Expected attribute \"" << pAttr << "\" for element <" << mReader->getNodeName() << ">." );
     return -1;
 }
 
@@ -3131,7 +3132,7 @@ Collada::InputType ColladaParser::GetTypeForSemantic( const std::string& pSemant
     else if( pSemantic == "TANGENT" || pSemantic == "TEXTANGENT")
         return IT_Tangent;
 
-    DefaultLogger::get()->warn( boost::str( boost::format( "Unknown vertex input type \"%s\". Ignoring.") % pSemantic));
+    DefaultLogger::get()->warn( format() << "Unknown vertex input type \"" << pSemantic << "\". Ignoring." );
     return IT_Invalid;
 }
 

code/ColladaParser.h

@@ -1,28 +1,28 @@
 /*
  Open Asset Import Library (assimp)
  ----------------------------------------------------------------------
- 
+
  Copyright (c) 2006-2016, 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
@@ -34,7 +34,7 @@
  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.
- 
+
  ----------------------------------------------------------------------
  */
 
@@ -48,12 +48,12 @@
 #include "irrXMLWrapper.h"
 #include "ColladaHelper.h"
 #include "../include/assimp/ai_assert.h"
-#include <boost/format.hpp>
-#include <boost/scoped_ptr.hpp>
+#include "TinyFormatter.h"
+#include <memory>
 
 namespace Assimp
 {
-    
+
     // ------------------------------------------------------------------------------------------
     /** Parser helper class for the Collada loader.
      *
@@ -63,23 +63,23 @@ namespace Assimp
     class ColladaParser
     {
         friend class ColladaLoader;
-        
+
     protected:
         /** Constructor from XML file */
         ColladaParser( IOSystem* pIOHandler, const std::string& pFile);
-        
+
         /** Destructor */
         ~ColladaParser();
-        
+
         /** Reads the contents of the file */
         void ReadContents();
-        
+
         /** Reads the structure of the file */
         void ReadStructure();
-        
+
         /** Reads asset informations such as coordinate system informations and legal blah */
         void ReadAssetInfo();
-        
+
         /** Reads the animation library */
         void ReadAnimationLibrary();
 
@@ -88,137 +88,137 @@ namespace Assimp
 
 		/** Re-build animations from animation clip library, if present, otherwise combine single-channel animations */
 		void PostProcessRootAnimations();
-        
+
         /** Reads an animation into the given parent structure */
         void ReadAnimation( Collada::Animation* pParent);
-        
+
         /** Reads an animation sampler into the given anim channel */
         void ReadAnimationSampler( Collada::AnimationChannel& pChannel);
-        
+
         /** Reads the skeleton controller library */
         void ReadControllerLibrary();
-        
+
         /** Reads a controller into the given mesh structure */
         void ReadController( Collada::Controller& pController);
-        
+
         /** Reads the joint definitions for the given controller */
         void ReadControllerJoints( Collada::Controller& pController);
-        
+
         /** Reads the joint weights for the given controller */
         void ReadControllerWeights( Collada::Controller& pController);
-        
+
         /** Reads the image library contents */
         void ReadImageLibrary();
-        
+
         /** Reads an image entry into the given image */
         void ReadImage( Collada::Image& pImage);
-        
+
         /** Reads the material library */
         void ReadMaterialLibrary();
-        
+
         /** Reads a material entry into the given material */
         void ReadMaterial( Collada::Material& pMaterial);
-        
+
         /** Reads the camera library */
         void ReadCameraLibrary();
-        
+
         /** Reads a camera entry into the given camera */
         void ReadCamera( Collada::Camera& pCamera);
-        
+
         /** Reads the light library */
         void ReadLightLibrary();
-        
+
         /** Reads a light entry into the given light */
         void ReadLight( Collada::Light& pLight);
-        
+
         /** Reads the effect library */
         void ReadEffectLibrary();
-        
+
         /** Reads an effect entry into the given effect*/
         void ReadEffect( Collada::Effect& pEffect);
-        
+
         /** Reads an COMMON effect profile */
         void ReadEffectProfileCommon( Collada::Effect& pEffect);
-        
+
         /** Read sampler properties */
         void ReadSamplerProperties( Collada::Sampler& pSampler);
-        
+
         /** Reads an effect entry containing a color or a texture defining that color */
         void ReadEffectColor( aiColor4D& pColor, Collada::Sampler& pSampler);
-        
+
         /** Reads an effect entry containing a float */
         void ReadEffectFloat( float& pFloat);
-        
+
         /** Reads an effect parameter specification of any kind */
         void ReadEffectParam( Collada::EffectParam& pParam);
-        
+
         /** Reads the geometry library contents */
         void ReadGeometryLibrary();
-        
+
         /** Reads a geometry from the geometry library. */
         void ReadGeometry( Collada::Mesh* pMesh);
-        
+
         /** Reads a mesh from the geometry library */
         void ReadMesh( Collada::Mesh* pMesh);
-        
+
         /** Reads a source element - a combination of raw data and an accessor defining
          * things that should not be redefinable. Yes, that's another rant.
          */
         void ReadSource();
-        
+
         /** Reads a data array holding a number of elements, and stores it in the global library.
          * Currently supported are array of floats and arrays of strings.
          */
         void ReadDataArray();
-        
+
         /** Reads an accessor and stores it in the global library under the given ID -
          * accessors use the ID of the parent <source> element
          */
         void ReadAccessor( const std::string& pID);
-        
+
         /** Reads input declarations of per-vertex mesh data into the given mesh */
         void ReadVertexData( Collada::Mesh* pMesh);
-        
+
         /** Reads input declarations of per-index mesh data into the given mesh */
         void ReadIndexData( Collada::Mesh* pMesh);
-        
+
         /** Reads a single input channel element and stores it in the given array, if valid */
         void ReadInputChannel( std::vector<Collada::InputChannel>& poChannels);
-        
+
         /** Reads a <p> primitive index list and assembles the mesh data into the given mesh */
         size_t ReadPrimitives( Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
                               size_t pNumPrimitives, const std::vector<size_t>& pVCount, Collada::PrimitiveType pPrimType);
-        
+
         /** Copies the data for a single primitive into the mesh, based on the InputChannels */
         void CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset,
                         Collada::Mesh* pMesh, std::vector<Collada::InputChannel>& pPerIndexChannels,
                         size_t currentPrimitive, const std::vector<size_t>& indices);
-        
+
         /** Reads one triangle of a tristrip into the mesh */
         void ReadPrimTriStrips(size_t numOffsets, size_t perVertexOffset, Collada::Mesh* pMesh,
                                std::vector<Collada::InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices);
-        
+
         /** Extracts a single object from an input channel and stores it in the appropriate mesh data array */
         void ExtractDataObjectFromChannel( const Collada::InputChannel& pInput, size_t pLocalIndex, Collada::Mesh* pMesh);
-        
+
         /** Reads the library of node hierarchies and scene parts */
         void ReadSceneLibrary();
-        
+
         /** Reads a scene node's contents including children and stores it in the given node */
         void ReadSceneNode( Collada::Node* pNode);
-        
+
         /** Reads a node transformation entry of the given type and adds it to the given node's transformation list. */
         void ReadNodeTransformation( Collada::Node* pNode, Collada::TransformType pType);
-        
+
         /** Reads a mesh reference in a node and adds it to the node's mesh list */
         void ReadNodeGeometry( Collada::Node* pNode);
-        
+
         /** Reads the collada scene */
         void ReadScene();
-        
+
         // Processes bind_vertex_input and bind elements
         void ReadMaterialVertexInputBinding( Collada::SemanticMappingTable& tbl);
-        
+
     protected:
         /** Aborts the file reading with an exception */
         AI_WONT_RETURN void ThrowException( const std::string& pError) const AI_WONT_RETURN_SUFFIX;
@@ -226,95 +226,95 @@ namespace Assimp
 
         /** Skips all data until the end node of the current element */
         void SkipElement();
-        
+
         /** Skips all data until the end node of the given element */
         void SkipElement( const char* pElement);
-        
+
         /** Compares the current xml element name to the given string and returns true if equal */
         bool IsElement( const char* pName) const;
-        
+
         /** Tests for the opening tag of the given element, throws an exception if not found */
         void TestOpening( const char* pName);
-        
+
         /** Tests for the closing tag of the given element, throws an exception if not found */
         void TestClosing( const char* pName);
-        
+
         /** Checks the present element for the presence of the attribute, returns its index
          or throws an exception if not found */
         int GetAttribute( const char* pAttr) const;
-        
+
         /** Returns the index of the named attribute or -1 if not found. Does not throw,
          therefore useful for optional attributes */
         int TestAttribute( const char* pAttr) const;
-        
+
         /** Reads the text contents of an element, throws an exception if not given.
          Skips leading whitespace. */
         const char* GetTextContent();
-        
+
         /** Reads the text contents of an element, returns NULL if not given.
          Skips leading whitespace. */
         const char* TestTextContent();
-        
+
         /** Reads a single bool from current text content */
         bool ReadBoolFromTextContent();
-        
+
         /** Reads a single float from current text content */
         float ReadFloatFromTextContent();
-        
+
         /** Calculates the resulting transformation from all the given transform steps */
         aiMatrix4x4 CalculateResultTransform( const std::vector<Collada::Transform>& pTransforms) const;
-        
+
         /** Determines the input data type for the given semantic string */
         Collada::InputType GetTypeForSemantic( const std::string& pSemantic);
-        
+
         /** Finds the item in the given library by its reference, throws if not found */
         template <typename Type> const Type& ResolveLibraryReference(
                                                                      const std::map<std::string, Type>& pLibrary, const std::string& pURL) const;
-        
+
     protected:
         /** Filename, for a verbose error message */
         std::string mFileName;
-        
+
         /** XML reader, member for everyday use */
         irr::io::IrrXMLReader* mReader;
-        
+
         /** All data arrays found in the file by ID. Might be referred to by actually
          everyone. Collada, you are a steaming pile of indirection. */
         typedef std::map<std::string, Collada::Data> DataLibrary;
         DataLibrary mDataLibrary;
-        
+
         /** Same for accessors which define how the data in a data array is accessed. */
         typedef std::map<std::string, Collada::Accessor> AccessorLibrary;
         AccessorLibrary mAccessorLibrary;
-        
+
         /** Mesh library: mesh by ID */
         typedef std::map<std::string, Collada::Mesh*> MeshLibrary;
         MeshLibrary mMeshLibrary;
-        
+
         /** node library: root node of the hierarchy part by ID */
         typedef std::map<std::string, Collada::Node*> NodeLibrary;
         NodeLibrary mNodeLibrary;
-        
+
         /** Image library: stores texture properties by ID */
         typedef std::map<std::string, Collada::Image> ImageLibrary;
         ImageLibrary mImageLibrary;
-        
+
         /** Effect library: surface attributes by ID */
         typedef std::map<std::string, Collada::Effect> EffectLibrary;
         EffectLibrary mEffectLibrary;
-        
+
         /** Material library: surface material by ID */
         typedef std::map<std::string, Collada::Material> MaterialLibrary;
         MaterialLibrary mMaterialLibrary;
-        
+
         /** Light library: surface light by ID */
         typedef std::map<std::string, Collada::Light> LightLibrary;
         LightLibrary mLightLibrary;
-        
+
         /** Camera library: surface material by ID */
         typedef std::map<std::string, Collada::Camera> CameraLibrary;
         CameraLibrary mCameraLibrary;
-        
+
         /** Controller library: joint controllers by ID */
         typedef std::map<std::string, Collada::Controller> ControllerLibrary;
         ControllerLibrary mControllerLibrary;
@@ -326,24 +326,24 @@ namespace Assimp
 		/** Animation clip library: clip animation references by ID */
 		typedef std::vector<std::pair<std::string, std::vector<std::string> > > AnimationClipLibrary;
 		AnimationClipLibrary mAnimationClipLibrary;
-        
+
         /** Pointer to the root node. Don't delete, it just points to one of
          the nodes in the node library. */
         Collada::Node* mRootNode;
-        
+
         /** Root animation container */
         Collada::Animation mAnims;
-        
+
         /** Size unit: how large compared to a meter */
         float mUnitSize;
-        
+
         /** Which is the up vector */
         enum { UP_X, UP_Y, UP_Z } mUpDirection;
-        
+
         /** Collada file format version */
         Collada::FormatVersion mFormat;
     };
-    
+
     // ------------------------------------------------------------------------------------------------
     // Check for element match
     inline bool ColladaParser::IsElement( const char* pName) const
@@ -351,7 +351,7 @@ namespace Assimp
         ai_assert( mReader->getNodeType() == irr::io::EXN_ELEMENT);
         return ::strcmp( mReader->getNodeName(), pName) == 0;
     }
-    
+
     // ------------------------------------------------------------------------------------------------
     // Finds the item in the given library by its reference, throws if not found
     template <typename Type>
@@ -359,10 +359,10 @@ namespace Assimp
     {
         typename std::map<std::string, Type>::const_iterator it = pLibrary.find( pURL);
         if( it == pLibrary.end())
-            ThrowException( boost::str( boost::format( "Unable to resolve library reference \"%s\".") % pURL));
+            ThrowException( Formatter::format() << "Unable to resolve library reference \"" << pURL << "\"." );
         return it->second;
     }
-    
+
 } // end of namespace Assimp
 
 #endif // AI_COLLADAPARSER_H_INC

code/D3MFImporter.cpp

@@ -0,0 +1,387 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2016, 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 "D3MFImporter.h"
+
+#include "../include/assimp/scene.h"
+#include "../contrib/unzip/unzip.h"
+#include "../include/assimp/IOStream.hpp"
+#include "../include/assimp/IOSystem.hpp"
+#include "../include/assimp/DefaultLogger.hpp"
+#include "irrXMLWrapper.h"
+#include "StringComparison.h"
+
+
+#include <string>
+#include <sstream>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+#include <memory>
+
+#include "../include/assimp/ai_assert.h"
+
+#include "D3MFOpcPackage.h"
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+namespace Assimp {
+
+namespace D3MF {
+
+
+namespace XmlTag {
+
+    const std::string model     = "model";
+    const std::string metadata  = "metadata";
+    const std::string resources = "resources";
+    const std::string object    = "object";
+    const std::string mesh      = "mesh";
+    const std::string vertices  = "vertices";
+    const std::string vertex    = "vertex";
+    const std::string triangles = "triangles";
+    const std::string triangle  = "triangle";
+    const std::string x         = "x";
+    const std::string y         = "y";
+    const std::string z         = "z";
+    const std::string v1        = "v1";
+    const std::string v2        = "v2";
+    const std::string v3        = "v3";
+    const std::string id        = "id";
+    const std::string name      = "name";
+    const std::string type      = "type";
+    const std::string build     = "build";
+    const std::string item      = "item";
+    const std::string objectid  = "objectid";
+    const std::string transform = "transform";
+
+}
+
+
+class XmlSerializer
+{
+public:
+    XmlSerializer(XmlReader* xmlReader)
+        : xmlReader(xmlReader)
+    {
+
+    }
+
+    void ImportXml(aiScene* scene)
+    {
+
+        scene->mFlags |= AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
+
+        scene->mRootNode = new aiNode();
+        std::vector<aiNode*> children;
+
+        while(ReadToEndElement(D3MF::XmlTag::model))
+        {         
+
+            if(xmlReader->getNodeName() == D3MF::XmlTag::object)
+            {
+                children.push_back(ReadObject(scene));
+            }
+            else if(xmlReader->getNodeName() == D3MF::XmlTag::build)
+            {
+
+            }
+        }        
+
+        if(scene->mRootNode->mName.length == 0)
+            scene->mRootNode->mName.Set("3MF");
+
+
+        scene->mNumMeshes = static_cast<unsigned int>(meshes.size());
+        scene->mMeshes = new aiMesh*[scene->mNumMeshes]();
+
+        std::copy(meshes.begin(), meshes.end(), scene->mMeshes);
+
+        scene->mRootNode->mNumChildren = static_cast<unsigned int>(children.size());
+        scene->mRootNode->mChildren = new aiNode*[scene->mRootNode->mNumChildren]();
+
+        std::copy(children.begin(), children.end(), scene->mRootNode->mChildren);
+
+    }
+
+private:
+    aiNode* ReadObject(aiScene* scene)
+    {        
+        ScopeGuard<aiNode> node(new aiNode());
+
+        std::vector<unsigned long> meshIds;
+
+        int id = std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::id.c_str()));
+        std::string name(xmlReader->getAttributeValue(D3MF::XmlTag::name.c_str()));
+        std::string type(xmlReader->getAttributeValue(D3MF::XmlTag::type.c_str()));
+
+        node->mParent = scene->mRootNode;
+        node->mName.Set(name);        
+
+        unsigned long meshIdx = meshes.size();
+
+        while(ReadToEndElement(D3MF::XmlTag::object))
+        {
+            if(xmlReader->getNodeName() == D3MF::XmlTag::mesh)
+            {                
+                auto mesh = ReadMesh();
+
+                mesh->mName.Set(name);
+                meshes.push_back(mesh);
+                meshIds.push_back(meshIdx);
+                meshIdx++;
+
+            }
+        }
+
+        node->mNumMeshes = static_cast<unsigned int>(meshIds.size());
+
+        node->mMeshes = new unsigned int[node->mNumMeshes];
+
+        std::copy(meshIds.begin(), meshIds.end(), node->mMeshes);
+
+        return node.dismiss();
+
+    }
+
+    aiMesh* ReadMesh()
+    {
+        aiMesh* mesh = new aiMesh();
+
+        while(ReadToEndElement(D3MF::XmlTag::mesh))
+        {            
+            if(xmlReader->getNodeName() == D3MF::XmlTag::vertices)
+            {
+                ImportVertices(mesh);
+            }
+            else if(xmlReader->getNodeName() == D3MF::XmlTag::triangles)
+            {
+                ImportTriangles(mesh);
+            }
+
+        }
+
+
+        return mesh;
+    }
+
+    void ImportVertices(aiMesh* mesh)
+    {
+        std::vector<aiVector3D> vertices;        
+
+        while(ReadToEndElement(D3MF::XmlTag::vertices))
+        {                        
+            if(xmlReader->getNodeName() == D3MF::XmlTag::vertex)
+            {                
+                vertices.push_back(ReadVertex());
+            }
+        }
+        mesh->mNumVertices = static_cast<unsigned int>(vertices.size());
+        mesh->mVertices = new aiVector3D[mesh->mNumVertices];
+
+        std::copy(vertices.begin(), vertices.end(), mesh->mVertices);
+
+    }
+    aiVector3D ReadVertex()
+    {        
+        aiVector3D vertex;
+        vertex.x = std::strtof(xmlReader->getAttributeValue(D3MF::XmlTag::x.c_str()), nullptr);
+        vertex.y = std::strtof(xmlReader->getAttributeValue(D3MF::XmlTag::y.c_str()), nullptr);
+        vertex.z = std::strtof(xmlReader->getAttributeValue(D3MF::XmlTag::z.c_str()), nullptr);        
+
+        return vertex;
+    }
+
+    void ImportTriangles(aiMesh* mesh)
+    {
+         std::vector<aiFace> faces;         
+
+
+         while(ReadToEndElement(D3MF::XmlTag::triangles))
+         {
+             if(xmlReader->getNodeName() == D3MF::XmlTag::triangle)
+             {
+                 faces.push_back(ReadTriangle());
+             }
+         }
+
+        mesh->mNumFaces = static_cast<unsigned int>(faces.size());
+        mesh->mFaces = new aiFace[mesh->mNumFaces];
+        mesh->mPrimitiveTypes = aiPrimitiveType_TRIANGLE;
+
+
+        std::copy(faces.begin(), faces.end(), mesh->mFaces);
+
+    }
+
+    aiFace ReadTriangle()
+    {
+        aiFace face;
+
+        face.mNumIndices = 3;
+        face.mIndices = new unsigned int[face.mNumIndices];
+        face.mIndices[0] = static_cast<unsigned int>(std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::v1.c_str())));
+        face.mIndices[1] = static_cast<unsigned int>(std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::v2.c_str())));
+        face.mIndices[2] = static_cast<unsigned int>(std::atoi(xmlReader->getAttributeValue(D3MF::XmlTag::v3.c_str())));
+
+        return face;
+    }
+
+private:
+
+    bool ReadToStartElement(const std::string& startTag)
+    {
+        while(xmlReader->read())
+        {
+            if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT && xmlReader->getNodeName() == startTag)
+            {
+                return true;
+            }
+            else if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT_END &&
+                     xmlReader->getNodeName() == startTag)
+            {
+                return false;
+            }
+        }
+        //DefaultLogger::get()->error("unexpected EOF, expected closing <" + closeTag + "> tag");
+        return false;
+    }
+
+    bool ReadToEndElement(const std::string& closeTag)
+    {
+        while(xmlReader->read())
+        {
+            if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT) {
+                return true;
+            }
+            else if (xmlReader->getNodeType() == irr::io::EXN_ELEMENT_END
+                     && xmlReader->getNodeName() == closeTag)
+            {
+                return false;
+            }
+        }
+        DefaultLogger::get()->error("unexpected EOF, expected closing <" + closeTag + "> tag");
+        return false;
+    }
+
+
+private:
+    std::vector<aiMesh*> meshes;
+    XmlReader* xmlReader;
+
+
+};
+
+} //namespace D3MF
+
+
+static const aiImporterDesc desc = {
+    "3mf Importer",
+    "",
+    "",
+    "http://3mf.io/",
+    aiImporterFlags_SupportBinaryFlavour | aiImporterFlags_SupportCompressedFlavour,
+    0,
+    0,
+    0,
+    0,
+    "3mf"
+};
+
+
+D3MFImporter::D3MFImporter()
+{
+
+}
+
+D3MFImporter::~D3MFImporter()
+{
+
+}
+
+bool D3MFImporter::CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const
+{    
+    const std::string extension = GetExtension(pFile);
+
+    if(extension == "3mf")
+    {
+        return true;
+    }
+    else if(!extension.length() || checkSig)
+    {
+        if(!pIOHandler)
+            return true;
+    }
+
+    return false;
+}
+
+void D3MFImporter::SetupProperties(const Importer *pImp)
+{
+
+}
+
+const aiImporterDesc *D3MFImporter::GetInfo() const
+{
+    return &desc;
+}
+
+void D3MFImporter::InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler)
+{
+
+
+    D3MF::D3MFOpcPackage opcPackage(pIOHandler, pFile);
+
+    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(opcPackage.RootStream()));
+    std::unique_ptr<D3MF::XmlReader> xmlReader(irr::io::createIrrXMLReader(xmlStream.get()));
+
+    D3MF::XmlSerializer xmlSerializer(xmlReader.get());
+
+
+    xmlSerializer.ImportXml(pScene);
+
+
+}
+
+}
+
+#endif // ASSIMP_BUILD_NO_3MF_IMPORTER

code/D3MFImporter.h

@@ -0,0 +1,68 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2016, 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 AI_D3MFLOADER_H_INCLUDED
+#define AI_D3MFLOADER_H_INCLUDED
+
+#include <vector>
+#include <cstdint>
+
+#include "BaseImporter.h"
+
+namespace Assimp {
+
+class D3MFImporter : public BaseImporter
+{
+public:
+    D3MFImporter();
+    ~D3MFImporter();
+
+    // BaseImporter interface
+public:
+    bool CanRead(const std::string &pFile, IOSystem *pIOHandler, bool checkSig) const;
+    void SetupProperties(const Importer *pImp);
+    const aiImporterDesc *GetInfo() const;
+
+protected:
+    void InternReadFile(const std::string &pFile, aiScene *pScene, IOSystem *pIOHandler);
+
+};
+}
+#endif // AI_D3MFLOADER_H_INCLUDED

code/D3MFOpcPackage.cpp

@@ -0,0 +1,598 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2016, 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 "D3MFOpcPackage.h"
+
+#include <memory>
+#include <vector>
+#include <map>
+#include <algorithm>
+#include <cassert>
+#include <cstdlib>
+
+
+#include "../contrib/unzip/unzip.h"
+#include "../include/assimp/IOStream.hpp"
+#include "../include/assimp/IOSystem.hpp"
+#include "../include/assimp/DefaultLogger.hpp"
+
+
+#include "../include/assimp/ai_assert.h"
+
+#include "Exceptional.h"
+
+
+
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
+namespace Assimp {
+
+namespace D3MF {
+
+
+
+namespace XmlTag {
+
+const std::string CONTENT_TYPES_ARCHIVE  = "[Content_Types].xml";
+const std::string ROOT_RELATIONSHIPS_ARCHIVE  = "_rels/.rels";
+const std::string SCHEMA_CONTENTTYPES         = "http://schemas.openxmlformats.org/package/2006/content-types";
+const std::string SCHEMA_RELATIONSHIPS        = "http://schemas.openxmlformats.org/package/2006/relationships";
+const std::string RELS_RELATIONSHIP_CONTAINER = "Relationships";
+const std::string RELS_RELATIONSHIP_NODE      = "Relationship";
+const std::string RELS_ATTRIB_TARGET         = "Target";
+const std::string RELS_ATTRIB_TYPE            = "Type";
+const std::string RELS_ATTRIB_ID              = "Id";
+const std::string PACKAGE_START_PART_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel";
+const std::string PACKAGE_PRINT_TICKET_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/printticket";
+const std::string PACKAGE_TEXTURE_RELATIONSHIP_TYPE = "http://schemas.microsoft.com/3dmanufacturing/2013/01/3dtexture";
+const std::string PACKAGE_CORE_PROPERTIES_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties";
+const std::string PACKAGE_THUMBNAIL_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/package/2006/relationships/metadata/thumbnail";
+
+
+}
+
+class IOSystem2Unzip {
+
+    public:
+
+        static voidpf open(voidpf opaque, const char* filename, int mode);
+
+        static uLong read(voidpf opaque, voidpf stream, void* buf, uLong size);
+
+        static uLong write(voidpf opaque, voidpf stream, const void* buf, uLong size);
+
+        static long tell(voidpf opaque, voidpf stream);
+
+        static long seek(voidpf opaque, voidpf stream, uLong offset, int origin);
+
+        static int close(voidpf opaque, voidpf stream);
+
+        static int testerror(voidpf opaque, voidpf stream);
+
+        static zlib_filefunc_def get(IOSystem* pIOHandler);
+};
+
+voidpf IOSystem2Unzip::open(voidpf opaque, const char* filename, int mode) {
+    IOSystem* io_system = reinterpret_cast<IOSystem*>(opaque);
+
+    const char* mode_fopen = NULL;
+    if((mode & ZLIB_FILEFUNC_MODE_READWRITEFILTER)==ZLIB_FILEFUNC_MODE_READ) {
+        mode_fopen = "rb";
+    } else {
+        if(mode & ZLIB_FILEFUNC_MODE_EXISTING) {
+            mode_fopen = "r+b";
+        } else {
+            if(mode & ZLIB_FILEFUNC_MODE_CREATE) {
+                mode_fopen = "wb";
+            }
+        }
+    }
+
+
+    return (voidpf) io_system->Open(filename, mode_fopen);
+}
+
+uLong IOSystem2Unzip::read(voidpf /*opaque*/, voidpf stream, void* buf, uLong size) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    return io_stream->Read(buf, 1, size);
+}
+
+uLong IOSystem2Unzip::write(voidpf /*opaque*/, voidpf stream, const void* buf, uLong size) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    return io_stream->Write(buf, 1, size);
+}
+
+long IOSystem2Unzip::tell(voidpf /*opaque*/, voidpf stream) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    return io_stream->Tell();
+}
+
+long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {
+    IOStream* io_stream = (IOStream*) stream;
+
+    aiOrigin assimp_origin;
+    switch (origin) {
+        default:
+        case ZLIB_FILEFUNC_SEEK_CUR:
+            assimp_origin = aiOrigin_CUR;
+            break;
+        case ZLIB_FILEFUNC_SEEK_END:
+            assimp_origin = aiOrigin_END;
+            break;
+        case ZLIB_FILEFUNC_SEEK_SET:
+            assimp_origin = aiOrigin_SET;
+            break;
+    }
+
+    return (io_stream->Seek(offset, assimp_origin) == aiReturn_SUCCESS ? 0 : -1);
+}
+
+int IOSystem2Unzip::close(voidpf opaque, voidpf stream) {
+    IOSystem* io_system = (IOSystem*) opaque;
+    IOStream* io_stream = (IOStream*) stream;
+
+    io_system->Close(io_stream);
+
+    return 0;
+}
+
+int IOSystem2Unzip::testerror(voidpf /*opaque*/, voidpf /*stream*/) {
+    return 0;
+}
+
+zlib_filefunc_def IOSystem2Unzip::get(IOSystem* pIOHandler) {
+    zlib_filefunc_def mapping;
+
+    mapping.zopen_file = open;
+    mapping.zread_file = read;
+    mapping.zwrite_file = write;
+    mapping.ztell_file = tell;
+    mapping.zseek_file = seek;
+    mapping.zclose_file = close;
+    mapping.zerror_file = testerror;
+    mapping.opaque = reinterpret_cast<voidpf>(pIOHandler);
+
+    return mapping;
+}
+
+
+class ZipFile : public IOStream
+{
+    friend class D3MFZipArchive;
+
+public:
+    explicit ZipFile(size_t size);
+
+    ~ZipFile();
+
+    size_t Read(void* pvBuffer, size_t pSize, size_t pCount );
+
+    size_t Write(const void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/);
+
+    size_t FileSize() const;
+
+    aiReturn Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/);
+
+    size_t Tell() const;
+
+    void Flush();
+
+private:
+
+    void* m_Buffer;
+
+    size_t m_Size;
+
+};
+
+ZipFile::ZipFile(size_t size) : m_Size(size) {
+    ai_assert(m_Size != 0);
+
+    m_Buffer = malloc(m_Size);
+}
+
+ZipFile::~ZipFile() {
+    free(m_Buffer);
+    m_Buffer = NULL;
+}
+
+size_t ZipFile::Read(void* pvBuffer, size_t pSize, size_t pCount) {
+    const size_t size = pSize * pCount;
+    assert(size <= m_Size);
+
+    std::memcpy(pvBuffer, m_Buffer, size);
+
+    return size;
+}
+
+size_t ZipFile::Write(const void* /*pvBuffer*/, size_t /*pSize*/, size_t /*pCount*/) {
+    return 0;
+}
+
+size_t ZipFile::FileSize() const {
+    return m_Size;
+}
+
+aiReturn ZipFile::Seek(size_t /*pOffset*/, aiOrigin /*pOrigin*/) {
+    return aiReturn_FAILURE;
+}
+
+size_t ZipFile::Tell() const {
+    return 0;
+}
+
+void ZipFile::Flush() {
+    // empty
+}
+
+
+class D3MFZipArchive : public IOSystem
+{
+public:
+
+    static const unsigned int FileNameSize = 256;
+
+public:
+
+    D3MFZipArchive(IOSystem* pIOHandler, const std::string & rFile);
+
+    ~D3MFZipArchive();
+
+    bool Exists(const char* pFile) const;
+
+    char getOsSeparator() const;
+
+    IOStream* Open(const char* pFile, const char* pMode = "rb");
+
+    void Close(IOStream* pFile);
+
+    bool isOpen() const;
+
+    void getFileList(std::vector<std::string> &rFileList);
+
+private:
+
+    bool mapArchive();
+
+private:
+
+    unzFile m_ZipFileHandle;
+
+    std::map<std::string, ZipFile*> m_ArchiveMap;
+
+};
+
+
+// ------------------------------------------------------------------------------------------------
+//  Constructor.
+D3MFZipArchive::D3MFZipArchive(IOSystem* pIOHandler, const std::string& rFile)
+    : m_ZipFileHandle(NULL), m_ArchiveMap()
+{
+    if (! rFile.empty())
+    {                
+        zlib_filefunc_def mapping = IOSystem2Unzip::get(pIOHandler);            
+
+        m_ZipFileHandle = unzOpen2(rFile.c_str(), &mapping);
+
+        if(m_ZipFileHandle != NULL) {            
+            mapArchive();
+        }
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Destructor.
+D3MFZipArchive::~D3MFZipArchive() {
+    for( std::map<std::string, ZipFile*>::iterator it(m_ArchiveMap.begin()), end(m_ArchiveMap.end()); it != end; ++it ) {
+        delete it->second;
+    }
+    m_ArchiveMap.clear();
+
+    if(m_ZipFileHandle != NULL) {
+        unzClose(m_ZipFileHandle);
+        m_ZipFileHandle = NULL;
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if the archive is already open.
+bool D3MFZipArchive::isOpen() const {
+    return (m_ZipFileHandle != NULL);
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns true, if the filename is part of the archive.
+bool D3MFZipArchive::Exists(const char* pFile) const {
+    ai_assert(pFile != NULL);
+
+    bool exist = false;
+
+    if (pFile != NULL) {
+        std::string rFile(pFile);
+        std::map<std::string, ZipFile*>::const_iterator it = m_ArchiveMap.find(rFile);
+
+        if(it != m_ArchiveMap.end()) {
+            exist = true;
+        }
+    }
+
+    return exist;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Returns the separator delimiter.
+char D3MFZipArchive::getOsSeparator() const {
+#ifndef _WIN32
+    return '/';
+#else
+    return '\\';
+#endif
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Opens a file, which is part of the archive.
+IOStream *D3MFZipArchive::Open(const char* pFile, const char* /*pMode*/) {
+    ai_assert(pFile != NULL);
+
+    IOStream* result = NULL;
+
+    std::map<std::string, ZipFile*>::iterator it = m_ArchiveMap.find(pFile);
+
+    if(it != m_ArchiveMap.end()) {
+        result = static_cast<IOStream*>(it->second);
+    }
+
+    return result;
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Close a filestream.
+void D3MFZipArchive::Close(IOStream *pFile) {
+    ai_assert(pFile != NULL);
+
+    // We don't do anything in case the file would be opened again in the future
+}
+// ------------------------------------------------------------------------------------------------
+//  Returns the file-list of the archive.
+void D3MFZipArchive::getFileList(std::vector<std::string> &rFileList) {
+    rFileList.clear();
+
+    for(std::map<std::string, ZipFile*>::iterator it(m_ArchiveMap.begin()), end(m_ArchiveMap.end()); it != end; ++it) {
+        rFileList.push_back(it->first);
+    }
+}
+
+// ------------------------------------------------------------------------------------------------
+//  Maps the archive content.
+bool D3MFZipArchive::mapArchive() {
+    bool success = false;
+
+    if(m_ZipFileHandle != NULL) {
+        if(m_ArchiveMap.empty()) {
+            //  At first ensure file is already open
+            if(unzGoToFirstFile(m_ZipFileHandle) == UNZ_OK) {
+                // Loop over all files
+                do {
+                    char filename[FileNameSize];
+                    unz_file_info fileInfo;
+
+                    if(unzGetCurrentFileInfo(m_ZipFileHandle, &fileInfo, filename, FileNameSize, NULL, 0, NULL, 0) == UNZ_OK) {
+                        // The file has EXACTLY the size of uncompressed_size. In C
+                        // you need to mark the last character with '\0', so add
+                        // another character
+                        if(fileInfo.uncompressed_size != 0 && unzOpenCurrentFile(m_ZipFileHandle) == UNZ_OK) {
+                            std::pair<std::map<std::string, ZipFile*>::iterator, bool> result = m_ArchiveMap.insert(std::make_pair(filename, new ZipFile(fileInfo.uncompressed_size)));
+
+                            if(unzReadCurrentFile(m_ZipFileHandle, result.first->second->m_Buffer, fileInfo.uncompressed_size) == (long int) fileInfo.uncompressed_size) {
+                                if(unzCloseCurrentFile(m_ZipFileHandle) == UNZ_OK) {
+                                    // Nothing to do anymore...
+                                }
+                            }
+                        }
+                    }
+                } while(unzGoToNextFile(m_ZipFileHandle) != UNZ_END_OF_LIST_OF_FILE);
+            }
+        }
+
+        success = true;
+    }
+
+    return success;
+}
+
+// ------------------------------------------------------------------------------------------------
+
+struct OpcPackageRelationship
+{
+    std::string id;
+    std::string type;
+    std::string target;
+};
+
+typedef std::shared_ptr<OpcPackageRelationship> OpcPackageRelationshipPtr;
+
+class OpcPackageRelationshipReader
+{
+public:
+
+    OpcPackageRelationshipReader(XmlReader* xmlReader)
+    {        
+
+        while(xmlReader->read())
+        {
+            if(xmlReader->getNodeType() == irr::io::EXN_ELEMENT &&
+               xmlReader->getNodeName() == XmlTag::RELS_RELATIONSHIP_CONTAINER)
+            {
+                ParseRootNode(xmlReader);
+            }
+        }
+
+
+    }
+    void ParseRootNode(XmlReader* xmlReader)
+    {       
+        ParseAttributes(xmlReader);
+
+        while(xmlReader->read())
+        {
+            if(xmlReader->getNodeType() == irr::io::EXN_ELEMENT &&
+               xmlReader->getNodeName() == XmlTag::RELS_RELATIONSHIP_NODE)
+            {
+                ParseChildNode(xmlReader);
+            }
+        }
+
+    }
+
+    void ParseAttributes(XmlReader*)
+    {
+
+    }
+    void ParseChildNode(XmlReader* xmlReader)
+    {        
+        OpcPackageRelationshipPtr relPtr(new OpcPackageRelationship());
+
+        relPtr->id = xmlReader->getAttributeValue(XmlTag::RELS_ATTRIB_ID.c_str());
+        relPtr->type = xmlReader->getAttributeValue(XmlTag::RELS_ATTRIB_TYPE.c_str());
+        relPtr->target = xmlReader->getAttributeValue(XmlTag::RELS_ATTRIB_TARGET.c_str());
+
+        m_relationShips.push_back(relPtr);
+    }
+    std::vector<OpcPackageRelationshipPtr> m_relationShips;
+
+};
+// ------------------------------------------------------------------------------------------------
+
+D3MFOpcPackage::D3MFOpcPackage(IOSystem* pIOHandler, const std::string& rFile)
+    : m_RootStream(nullptr)
+{    
+
+    zipArchive.reset(new D3MF::D3MFZipArchive( pIOHandler, rFile ));    
+    if(!zipArchive->isOpen())
+        throw DeadlyImportError("Failed to open file " + rFile+ ".");
+
+    std::vector<std::string> fileList;
+    zipArchive->getFileList(fileList);
+
+    for(auto& file: fileList){
+
+        if(file == D3MF::XmlTag::ROOT_RELATIONSHIPS_ARCHIVE)
+        {
+
+            //PkgRelationshipReader pkgRelReader(file, archive);
+            ai_assert(zipArchive->Exists(file.c_str()));
+
+            IOStream *fileStream = zipArchive->Open(file.c_str());
+
+            ai_assert(fileStream != nullptr);
+
+            std::string rootFile = ReadPackageRootRelationship(fileStream);
+            if(rootFile.size() > 0 && rootFile[0] == '/')
+                rootFile = rootFile.substr(1);
+
+            DefaultLogger::get()->debug(rootFile);
+
+            m_RootStream = zipArchive->Open(rootFile.c_str());
+
+            ai_assert(m_RootStream != nullptr);
+
+
+
+
+        //    const size_t size = zipArchive->FileSize();
+        //    m_Data.resize( size );
+
+        //    const size_t readSize = pMapFile->Read( &m_Data[0], sizeof( char ), size );
+        //    if ( readSize != size )
+        //    {
+        //        m_Data.clear();
+        //        return false;
+        //    }
+            zipArchive->Close( fileStream );
+
+        }
+        else if( file == D3MF::XmlTag::CONTENT_TYPES_ARCHIVE)
+        {
+
+        }
+    }
+}
+
+D3MFOpcPackage::~D3MFOpcPackage()
+{
+
+}
+
+IOStream* D3MFOpcPackage::RootStream() const
+{
+    return m_RootStream;
+}
+
+
+std::string D3MFOpcPackage::ReadPackageRootRelationship(IOStream* stream)
+{
+
+    std::unique_ptr<CIrrXML_IOStreamReader> xmlStream(new CIrrXML_IOStreamReader(stream));
+    std::unique_ptr<XmlReader> xml(irr::io::createIrrXMLReader(xmlStream.get()));
+
+    OpcPackageRelationshipReader reader(xml.get());
+
+
+    auto itr = std::find_if(reader.m_relationShips.begin(), reader.m_relationShips.end(), [](const OpcPackageRelationshipPtr& rel){
+        return rel->type == XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE;
+    });
+
+
+
+    if(itr == reader.m_relationShips.end())
+        throw DeadlyImportError("Cannot find" + XmlTag::PACKAGE_START_PART_RELATIONSHIP_TYPE);
+
+    return (*itr)->target;
+}
+
+} //namespace D3MF
+
+}
+
+#endif //ASSIMP_BUILD_NO_3MF_IMPORTER

code/D3MFOpcPackage.h

@@ -0,0 +1,76 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2016, 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 D3MFOPCPACKAGE_H
+#define D3MFOPCPACKAGE_H
+
+#include <string>
+#include <memory>
+
+#include "../include/assimp/IOSystem.hpp"
+#include "irrXMLWrapper.h"
+
+namespace Assimp {
+
+namespace D3MF {
+
+typedef irr::io::IrrXMLReader XmlReader;
+typedef std::shared_ptr<XmlReader> XmlReaderPtr;
+
+class D3MFZipArchive;
+
+class D3MFOpcPackage
+{
+public:
+    D3MFOpcPackage(IOSystem* pIOHandler, const std::string& rFile);
+    ~D3MFOpcPackage();
+
+    IOStream* RootStream() const;
+private:
+    std::string ReadPackageRootRelationship(IOStream* stream);
+private:
+    IOStream* m_RootStream;
+    std::unique_ptr<D3MFZipArchive> zipArchive;
+};
+
+}
+}
+
+#endif // D3MFOPCPACKAGE_H

code/DXFHelper.h

@@ -213,7 +213,7 @@ struct InsertBlock
 // keeps track of all geometry in a single BLOCK.
 struct Block
 {
-    std::vector< boost::shared_ptr<PolyLine> > lines;
+    std::vector< std::shared_ptr<PolyLine> > lines;
     std::vector<InsertBlock> insertions;
 
     std::string name;

code/DXFLoader.cpp

@@ -54,7 +54,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "DXFHelper.h"
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/scene.h"
-#include <boost/foreach.hpp>
 #include <numeric>
 
 using namespace Assimp;
@@ -134,7 +133,7 @@ void DXFImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene,
     IOSystem* pIOHandler)
 {
-    boost::shared_ptr<IOStream> file = boost::shared_ptr<IOStream>( pIOHandler->Open( pFile) );
+    std::shared_ptr<IOStream> file = std::shared_ptr<IOStream>( pIOHandler->Open( pFile) );
 
     // Check whether we can read the file
     if( file.get() == NULL) {
@@ -175,7 +174,7 @@ void DXFImporter::InternReadFile( const std::string& pFile,
         }
 
         // skip unneeded sections entirely to avoid any problems with them
-        // alltogether.
+        // altogether.
         else if (reader.Is(2,"CLASSES") || reader.Is(2,"TABLES")) {
             SkipSection(reader);
             continue;
@@ -222,8 +221,8 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
     if (!DefaultLogger::isNullLogger()) {
 
         unsigned int vcount = 0, icount = 0;
-        BOOST_FOREACH (const DXF::Block& bl, output.blocks) {
-            BOOST_FOREACH (boost::shared_ptr<const DXF::PolyLine> pl, bl.lines) {
+        for (const DXF::Block& bl : output.blocks) {
+            for (std::shared_ptr<const DXF::PolyLine> pl : bl.lines) {
                 vcount += pl->positions.size();
                 icount += pl->counts.size();
             }
@@ -242,7 +241,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
 
     // index blocks by name
     DXF::BlockMap blocks_by_name;
-    BOOST_FOREACH (DXF::Block& bl, output.blocks) {
+    for (DXF::Block& bl : output.blocks) {
         blocks_by_name[bl.name] = &bl;
         if ( !entities && bl.name == AI_DXF_ENTITIES_MAGIC_BLOCK ) {
             entities = &bl;
@@ -263,7 +262,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
     ExpandBlockReferences(*entities,blocks_by_name);
 
     unsigned int cur = 0;
-    BOOST_FOREACH (boost::shared_ptr<const DXF::PolyLine> pl, entities->lines) {
+    for (std::shared_ptr<const DXF::PolyLine> pl : entities->lines) {
         if (pl->positions.size()) {
 
             std::map<std::string, unsigned int>::iterator it = layers.find(pl->layer);
@@ -289,12 +288,12 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
 
     pScene->mMeshes = new aiMesh*[ pScene->mNumMeshes ] ();
 
-    BOOST_FOREACH(const LayerMap::value_type& elem, layers){
+    for(const LayerMap::value_type& elem : layers){
         aiMesh* const mesh =  pScene->mMeshes[elem.second] = new aiMesh();
         mesh->mName.Set(elem.first);
 
         unsigned int cvert = 0,cface = 0;
-        BOOST_FOREACH(const DXF::PolyLine* pl, corr[elem.second]){
+        for(const DXF::PolyLine* pl : corr[elem.second]){
             // sum over all faces since we need to 'verbosify' them.
             cvert += std::accumulate(pl->counts.begin(),pl->counts.end(),0);
             cface += pl->counts.size();
@@ -309,10 +308,10 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
 
         unsigned int prims = 0;
         unsigned int overall_indices = 0;
-        BOOST_FOREACH(const DXF::PolyLine* pl, corr[elem.second]){
+        for(const DXF::PolyLine* pl : corr[elem.second]){
 
             std::vector<unsigned int>::const_iterator it = pl->indices.begin();
-            BOOST_FOREACH(unsigned int facenumv,pl->counts) {
+            for(unsigned int facenumv : pl->counts) {
                 aiFace& face = *faces++;
                 face.mIndices = new unsigned int[face.mNumIndices = facenumv];
 
@@ -358,7 +357,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
 // ------------------------------------------------------------------------------------------------
 void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& blocks_by_name)
 {
-    BOOST_FOREACH (const DXF::InsertBlock& insert, bl.insertions) {
+    for (const DXF::InsertBlock& insert : bl.insertions) {
 
         // first check if the referenced blocks exists ...
         const DXF::BlockMap::const_iterator it = blocks_by_name.find(insert.name);
@@ -372,8 +371,8 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
         // XXX this would be the place to implement recursive expansion if needed.
         const DXF::Block& bl_src = *(*it).second;
 
-        BOOST_FOREACH (boost::shared_ptr<const DXF::PolyLine> pl_in, bl_src.lines) {
-            boost::shared_ptr<DXF::PolyLine> pl_out = boost::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
+        for (std::shared_ptr<const DXF::PolyLine> pl_in : bl_src.lines) {
+            std::shared_ptr<DXF::PolyLine> pl_out = std::shared_ptr<DXF::PolyLine>(new DXF::PolyLine(*pl_in));
 
             if (bl_src.base.Length() || insert.scale.x!=1.f || insert.scale.y!=1.f || insert.scale.z!=1.f || insert.angle || insert.pos.Length()) {
                 // manual coordinate system transformation
@@ -388,7 +387,7 @@ void DXFImporter::ExpandBlockReferences(DXF::Block& bl,const DXF::BlockMap& bloc
                     DefaultLogger::get()->warn("DXF: BLOCK rotation not currently implemented");
                 }
 
-                BOOST_FOREACH (aiVector3D& v, pl_out->positions) {
+                for (aiVector3D& v : pl_out->positions) {
                     v *= trafo;
                 }
             }
@@ -618,7 +617,7 @@ void DXFImporter::ParseInsertion(DXF::LineReader& reader, DXF::FileData& output)
 // ------------------------------------------------------------------------------------------------
 void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
 {
-    output.blocks.back().lines.push_back( boost::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
+    output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() ) );
     DXF::PolyLine& line = *output.blocks.back().lines.back();
 
     unsigned int iguess = 0, vguess = 0;
@@ -800,7 +799,7 @@ void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
     // (note) this is also used for for parsing line entities, so we
     // must handle the vertex_count == 2 case as well.
 
-    output.blocks.back().lines.push_back( boost::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() )  );
+    output.blocks.back().lines.push_back( std::shared_ptr<DXF::PolyLine>( new DXF::PolyLine() )  );
     DXF::PolyLine& line = *output.blocks.back().lines.back();
 
     aiVector3D vip[4];

code/DefaultIOStream.cpp

@@ -45,7 +45,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../include/assimp/ai_assert.h"
 #include "DefaultIOStream.h"
-#include <boost/static_assert.hpp>
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ -86,8 +85,9 @@ aiReturn DefaultIOStream::Seek(size_t pOffset,
     }
 
     // Just to check whether our enum maps one to one with the CRT constants
-    BOOST_STATIC_ASSERT(aiOrigin_CUR == SEEK_CUR &&
-        aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET);
+    static_assert(aiOrigin_CUR == SEEK_CUR &&
+        aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET, "aiOrigin_CUR == SEEK_CUR && \
+        aiOrigin_END == SEEK_END && aiOrigin_SET == SEEK_SET");
 
     // do the seek
     return (0 == ::fseek(mFile, (long)pOffset,(int)pOrigin) ? AI_SUCCESS : AI_FAILURE);

code/DefaultLogger.cpp

@@ -57,10 +57,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <stdio.h>
 
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-#   include <boost/thread/thread.hpp>
-#   include <boost/thread/mutex.hpp>
+#   include <thread>
+#   include <mutex>
 
-boost::mutex loggerMutex;
+std::mutex loggerMutex;
 #endif
 
 namespace Assimp    {
@@ -135,7 +135,7 @@ Logger *DefaultLogger::create(const char* name /*= "AssimpLog.txt"*/,
 {
     // enter the mutex here to avoid concurrency problems
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-    boost::mutex::scoped_lock lock(loggerMutex);
+    std::lock_guard<std::mutex> lock(loggerMutex);
 #endif
 
     if (m_pLogger && !isNullLogger() )
@@ -210,7 +210,7 @@ void DefaultLogger::set( Logger *logger )
 {
     // enter the mutex here to avoid concurrency problems
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-    boost::mutex::scoped_lock lock(loggerMutex);
+    std::lock_guard<std::mutex> lock(loggerMutex);
 #endif
 
     if (!logger)logger = &s_pNullLogger;
@@ -237,7 +237,7 @@ void DefaultLogger::kill()
 {
     // enter the mutex here to avoid concurrency problems
 #ifndef ASSIMP_BUILD_SINGLETHREADED
-    boost::mutex::scoped_lock lock(loggerMutex);
+    std::lock_guard<std::mutex> lock(loggerMutex);
 #endif
 
 	if ( m_pLogger == &s_pNullLogger ) {
@@ -413,7 +413,8 @@ void DefaultLogger::WriteToStreams(const char *message, ErrorSeverity ErrorSev )
 //  Returns thread id, if not supported only a zero will be returned.
 unsigned int DefaultLogger::GetThreadID()
 {
-    // fixme: we can get this value via boost::threads
+    // fixme: we can get this value via std::threads
+    // std::this_thread::get_id().hash() returns a (big) size_t, not sure if this is useful in this case.
 #ifdef WIN32
     return (unsigned int)::GetCurrentThreadId();
 #else

code/Exporter.cpp

@@ -63,7 +63,7 @@ Here we implement only the C++ interface (Assimp::Exporter).
 #include "ConvertToLHProcess.h"
 #include "Exceptional.h"
 #include "ScenePrivate.h"
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "../include/assimp/Exporter.hpp"
 #include "../include/assimp/mesh.h"
 #include "../include/assimp/postprocess.h"
@@ -184,7 +184,7 @@ public:
 public:
 
     aiExportDataBlob* blob;
-    boost::shared_ptr< Assimp::IOSystem > mIOSystem;
+    std::shared_ptr< Assimp::IOSystem > mIOSystem;
     bool mIsDefaultIOHandler;
 
     /** Post processing steps we can apply at the imported data. */
@@ -254,10 +254,10 @@ const aiExportDataBlob* Exporter :: ExportToBlob(  const aiScene* pScene, const
     }
 
 
-    boost::shared_ptr<IOSystem> old = pimpl->mIOSystem;
+    std::shared_ptr<IOSystem> old = pimpl->mIOSystem;
 
     BlobIOSystem* blobio = new BlobIOSystem();
-    pimpl->mIOSystem = boost::shared_ptr<IOSystem>( blobio );
+    pimpl->mIOSystem = std::shared_ptr<IOSystem>( blobio );
 
     if (AI_SUCCESS != Export(pScene,pFormatId,blobio->GetMagicFileName())) {
         pimpl->mIOSystem = old;
@@ -324,7 +324,7 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
                 aiScene* scenecopy_tmp;
                 SceneCombiner::CopyScene(&scenecopy_tmp,pScene);
 
-                std::auto_ptr<aiScene> scenecopy(scenecopy_tmp);
+                std::unique_ptr<aiScene> scenecopy(scenecopy_tmp);
                 const ScenePrivateData* const priv = ScenePriv(pScene);
 
                 // steps that are not idempotent, i.e. we might need to run them again, usually to get back to the
@@ -491,7 +491,7 @@ const aiExportFormatDesc* Exporter :: GetExportFormatDescription( size_t pIndex
 // ------------------------------------------------------------------------------------------------
 aiReturn Exporter :: RegisterExporter(const ExportFormatEntry& desc)
 {
-    BOOST_FOREACH(const ExportFormatEntry& e, pimpl->mExporters) {
+    for(const ExportFormatEntry& e : pimpl->mExporters) {
         if (!strcmp(e.mDescription.id,desc.mDescription.id)) {
             return aiReturn_FAILURE;
         }

code/FBXAnimation.cpp

@@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
-#include <boost/foreach.hpp>
 
 namespace Assimp {
 namespace FBX {
@@ -110,7 +109,7 @@ AnimationCurveNode::AnimationCurveNode(uint64_t id, const Element& element, cons
     const char* whitelist[] = {"Model","NodeAttribute"};
     const std::vector<const Connection*>& conns = doc.GetConnectionsBySourceSequenced(ID(),whitelist,2);
 
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
 
         // link should go for a property
         if (!con->PropertyName().length()) {
@@ -171,7 +170,7 @@ const AnimationCurveMap& AnimationCurveNode::Curves() const
         // resolve attached animation curves
         const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationCurve");
 
-        BOOST_FOREACH(const Connection* con, conns) {
+        for(const Connection* con : conns) {
 
             // link should go for a property
             if (!con->PropertyName().length()) {
@@ -227,7 +226,7 @@ AnimationCurveNodeList AnimationLayer::Nodes(const char* const * target_prop_whi
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationCurveNode");
     nodes.reserve(conns.size());
 
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
 
         // link should not go to a property
         if (con->PropertyName().length()) {
@@ -278,7 +277,7 @@ AnimationStack::AnimationStack(uint64_t id, const Element& element, const std::s
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"AnimationLayer");
     layers.reserve(conns.size());
 
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
 
         // link should not go to a property
         if (con->PropertyName().length()) {

code/FBXBinaryTokenizer.cpp

@@ -191,7 +191,7 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 
         // 32 bit int
     case 'I':
-        // <- fall thru
+        // <- fall through
 
         // float
     case 'F':

code/FBXConverter.h

@@ -49,17 +49,16 @@ struct aiScene;
 namespace Assimp {
 namespace FBX {
 
-    class Document;
+class Document;
 
-
-/** Convert a FBX #Document to #aiScene
+/** 
+ *  Convert a FBX #Document to #aiScene
  *  @param out Empty scene to be populated
- *  @param doc Parsed FBX document */
+ *  @param doc Parsed FBX document 
+ */
 void ConvertToAssimpScene(aiScene* out, const Document& doc);
 
-
 }
 }
 
-
-#endif
+#endif // INCLUDED_AI_FBX_CONVERTER_H

code/FBXDeformer.cpp

@@ -50,7 +50,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
-#include <boost/foreach.hpp>
 
 namespace Assimp {
 namespace FBX {
@@ -107,7 +106,7 @@ Cluster::Cluster(uint64_t id, const Element& element, const Document& doc, const
 
     // read assigned node
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"Model");
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
         const Model* const mod = ProcessSimpleConnection<Model>(*con, false, "Model -> Cluster", element);
         if(mod) {
             node = mod;
@@ -143,7 +142,7 @@ Skin::Skin(uint64_t id, const Element& element, const Document& doc, const std::
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"Deformer");
 
     clusters.reserve(conns.size());
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
 
         const Cluster* const cluster = ProcessSimpleConnection<Cluster>(*con, false, "Cluster -> Skin", element);
         if(cluster) {

code/FBXDocument.cpp

@@ -44,17 +44,18 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 
-#include <functional>
-
-#include "FBXParser.h"
 #include "FBXDocument.h"
+#include "FBXMeshGeometry.h"
+#include "FBXParser.h"
 #include "FBXUtil.h"
 #include "FBXImporter.h"
 #include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
-#include <boost/foreach.hpp>
-#include <boost/make_shared.hpp>
+
+#include <memory>
+#include <functional>
+
 
 namespace Assimp {
 namespace FBX {
@@ -77,6 +78,12 @@ LazyObject::~LazyObject()
 
 }
 
+// ------------------------------------------------------------------------------------------------
+static void dumpObjectClassInfo( const char* obtype, const std::string &classtag ) {
+    DefaultLogger::get()->debug( "obtype: " + std::string(obtype ));
+    DefaultLogger::get()->debug( "Classtag: " + classtag );
+}
+
 // ------------------------------------------------------------------------------------------------
 const Object* LazyObject::Get(bool dieOnError)
 {
@@ -135,6 +142,10 @@ const Object* LazyObject::Get(bool dieOnError)
         // so avoid constructing strings all the time.
         const char* obtype = key.begin();
         const size_t length = static_cast<size_t>(key.end()-key.begin());
+
+        // For debugging
+        //dumpObjectClassInfo( objtype, classtag );
+
         if (!strncmp(obtype,"Geometry",length)) {
             if (!strcmp(classtag.c_str(),"Mesh")) {
                 object.reset(new MeshGeometry(id,element,name,doc));
@@ -165,10 +176,10 @@ const Object* LazyObject::Get(bool dieOnError)
                 object.reset(new Skin(id,element,doc,name));
             }
         }
-        else if (!strncmp(obtype,"Model",length)) {
+        else if ( !strncmp( obtype, "Model", length ) ) {
             // FK and IK effectors are not supported
-            if (strcmp(classtag.c_str(),"IKEffector") && strcmp(classtag.c_str(),"FKEffector")) {
-                object.reset(new Model(id,element,doc,name));
+            if ( strcmp( classtag.c_str(), "IKEffector" ) && strcmp( classtag.c_str(), "FKEffector" ) ) {
+                object.reset( new Model( id, element, doc, name ) );
             }
         }
         else if (!strncmp(obtype,"Material",length)) {
@@ -237,7 +248,7 @@ Object::~Object()
 
 
 // ------------------------------------------------------------------------------------------------
-FileGlobalSettings::FileGlobalSettings(const Document& doc, boost::shared_ptr<const PropertyTable> props)
+FileGlobalSettings::FileGlobalSettings(const Document& doc, std::shared_ptr<const PropertyTable> props)
 : props(props)
 , doc(doc)
 {
@@ -278,18 +289,20 @@ Document::Document(const Parser& parser, const ImportSettings& settings)
 // ------------------------------------------------------------------------------------------------
 Document::~Document()
 {
-    BOOST_FOREACH(ObjectMap::value_type& v, objects) {
+    for(ObjectMap::value_type& v : objects) {
         delete v.second;
     }
 
-    BOOST_FOREACH(ConnectionMap::value_type& v, src_connections) {
+    for(ConnectionMap::value_type& v : src_connections) {
         delete v.second;
     }
     // |dest_connections| contain the same Connection objects as the |src_connections|
 }
 
-
 // ------------------------------------------------------------------------------------------------
+static const int LowerSupportedVersion = 7100;
+static const int UpperSupportedVersion = 7400;
+
 void Document::ReadHeader()
 {
     // Read ID objects from "Objects" section
@@ -304,10 +317,10 @@ void Document::ReadHeader()
 
     // While we maye have some success with newer files, we don't support
     // the older 6.n fbx format
-    if(fbxVersion < 7100) {
+    if(fbxVersion < LowerSupportedVersion ) {
         DOMError("unsupported, old format version, supported are only FBX 2011, FBX 2012 and FBX 2013");
     }
-    if(fbxVersion > 7300) {
+    if(fbxVersion > UpperSupportedVersion ) {
         if(Settings().strictMode) {
             DOMError("unsupported, newer format version, supported are only FBX 2011, FBX 2012 and FBX 2013"
                 " (turn off strict mode to try anyhow) ");
@@ -345,11 +358,11 @@ void Document::ReadGlobalSettings()
     if(!ehead || !ehead->Compound()) {
         DOMWarning("no GlobalSettings dictionary found");
 
-        globals.reset(new FileGlobalSettings(*this, boost::make_shared<const PropertyTable>()));
+        globals.reset(new FileGlobalSettings(*this, std::make_shared<const PropertyTable>()));
         return;
     }
 
-    boost::shared_ptr<const PropertyTable> props = GetPropertyTable(*this, "", *ehead, *ehead->Compound(), true);
+    std::shared_ptr<const PropertyTable> props = GetPropertyTable(*this, "", *ehead, *ehead->Compound(), true);
 
     if(!props) {
         DOMError("GlobalSettings dictionary contains no property table");
@@ -374,7 +387,7 @@ void Document::ReadObjects()
     objects[0] = new LazyObject(0L, *eobjects, *this);
 
     const Scope& sobjects = *eobjects->Compound();
-    BOOST_FOREACH(const ElementMap::value_type& el, sobjects.Elements()) {
+    for(const ElementMap::value_type& el : sobjects.Elements()) {
 
         // extract ID
         const TokenList& tok = el.second->Tokens();
@@ -408,7 +421,6 @@ void Document::ReadObjects()
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
 void Document::ReadPropertyTemplates()
 {
@@ -457,8 +469,8 @@ void Document::ReadPropertyTemplates()
 
             const Element* Properties70 = (*sc)["Properties70"];
             if(Properties70) {
-                boost::shared_ptr<const PropertyTable> props = boost::make_shared<const PropertyTable>(
-                    *Properties70,boost::shared_ptr<const PropertyTable>(static_cast<const PropertyTable*>(NULL))
+                std::shared_ptr<const PropertyTable> props = std::make_shared<const PropertyTable>(
+                    *Properties70,std::shared_ptr<const PropertyTable>(static_cast<const PropertyTable*>(NULL))
                 );
 
                 templates[oname+"."+pname] = props;
@@ -525,7 +537,7 @@ const std::vector<const AnimationStack*>& Document::AnimationStacks() const
     }
 
     animationStacksResolved.reserve(animationStacks.size());
-    BOOST_FOREACH(uint64_t id, animationStacks) {
+    for(uint64_t id : animationStacks) {
         LazyObject* const lazy = GetObject(id);
         const AnimationStack* stack;
         if(!lazy || !(stack = lazy->Get<AnimationStack>())) {

code/FBXDocument.h

@@ -44,16 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_DOCUMENT_H
 #define INCLUDED_AI_FBX_DOCUMENT_H
 
-#include <vector>
-#include <map>
-#include <string>
-#include <stdint.h>
 #include <numeric>
-#include <boost/scoped_ptr.hpp>
-#include "../include/assimp/ai_assert.h"
-#include "../include/assimp/vector3.h"
-#include "../include/assimp/vector2.h"
-#include "../include/assimp/color4.h"
+#include <stdint.h>
 #include "../include/assimp/mesh.h"
 #include "FBXProperties.h"
 #include "FBXParser.h"
@@ -64,24 +56,24 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace FBX {
 
-    class Parser;
-    class Object;
-    struct ImportSettings;
+class Parser;
+class Object;
+struct ImportSettings;
 
-    class PropertyTable;
-    class Document;
-    class Material;
-    class Geometry;
+class PropertyTable;
+class Document;
+class Material;
+class Geometry;
 
-    class Video;
+class Video;
 
-    class AnimationCurve;
-    class AnimationCurveNode;
-    class AnimationLayer;
-    class AnimationStack;
+class AnimationCurve;
+class AnimationCurveNode;
+class AnimationLayer;
+class AnimationStack;
 
-    class Skin;
-    class Cluster;
+class Skin;
+class Cluster;
 
 
 /** Represents a delay-parsed FBX objects. Many objects in the scene
@@ -90,7 +82,6 @@ namespace FBX {
 class LazyObject
 {
 public:
-
     LazyObject(uint64_t id, const Element& element, const Document& doc);
     ~LazyObject();
 
@@ -125,10 +116,9 @@ public:
     }
 
 private:
-
     const Document& doc;
     const Element& element;
-    boost::scoped_ptr<const Object> object;
+    std::unique_ptr<const Object> object;
 
     const uint64_t id;
 
@@ -146,11 +136,9 @@ private:
 class Object
 {
 public:
-
     Object(uint64_t id, const Element& element, const std::string& name);
-    virtual ~Object();
 
-public:
+    virtual ~Object();
 
     const Element& SourceElement() const {
         return element;
@@ -177,11 +165,8 @@ protected:
 class NodeAttribute : public Object
 {
 public:
-
     NodeAttribute(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~NodeAttribute();
-
-public:
+    virtual ~NodeAttribute();
 
     const PropertyTable& Props() const {
         ai_assert(props.get());
@@ -189,8 +174,7 @@ public:
     }
 
 private:
-
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
 };
 
 
@@ -198,11 +182,8 @@ private:
 class CameraSwitcher : public NodeAttribute
 {
 public:
-
     CameraSwitcher(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~CameraSwitcher();
-
-public:
+    virtual ~CameraSwitcher();
 
     int CameraID() const {
         return cameraId;
@@ -212,13 +193,11 @@ public:
         return cameraName;
     }
 
-
     const std::string& CameraIndexName() const {
         return cameraIndexName;
     }
 
 private:
-
     int cameraId;
     std::string cameraName;
     std::string cameraIndexName;
@@ -244,17 +223,14 @@ private:
 }
 
 
-
 /** DOM base class for FBX cameras attached to a node */
 class Camera : public NodeAttribute
 {
 public:
-
     Camera(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Camera();
+    virtual  ~Camera();
 
 public:
-
     fbx_simple_property(Position, aiVector3D, aiVector3D(0,0,0))
     fbx_simple_property(UpVector, aiVector3D, aiVector3D(0,1,0))
     fbx_simple_property(InterestPosition, aiVector3D, aiVector3D(0,0,0))
@@ -269,8 +245,6 @@ public:
 
     fbx_simple_property(FieldOfView, float, 1.0f)
     fbx_simple_property(FocalLength, float, 1.0f)
-
-private:
 };
 
 
@@ -278,9 +252,8 @@ private:
 class Null : public NodeAttribute
 {
 public:
-
     Null(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Null();
+    virtual ~Null();
 };
 
 
@@ -288,9 +261,8 @@ public:
 class LimbNode : public NodeAttribute
 {
 public:
-
     LimbNode(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~LimbNode();
+    virtual ~LimbNode();
 };
 
 
@@ -298,12 +270,10 @@ public:
 class Light : public NodeAttribute
 {
 public:
-
     Light(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Light();
+    virtual ~Light();
 
 public:
-
     enum Type
     {
         Type_Point,
@@ -326,7 +296,6 @@ public:
     };
 
 public:
-
     fbx_simple_property(Color, aiVector3D, aiVector3D(1,1,1))
     fbx_simple_enum_property(LightType, Type, 0)
     fbx_simple_property(CastLightOnObject, bool, false)
@@ -358,9 +327,6 @@ public:
     fbx_simple_property(TopBarnDoor, float, 20.0f)
     fbx_simple_property(BottomBarnDoor, float, 20.0f)
     fbx_simple_property(EnableBarnDoor, bool, true)
-
-
-private:
 };
 
 
@@ -368,12 +334,10 @@ private:
 class Model : public Object
 {
 public:
-
     Model(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Model();
+    virtual ~Model();
 
 public:
-
     enum RotOrder
     {
         RotOrder_EulerXYZ = 0,
@@ -399,7 +363,6 @@ public:
     };
 
 public:
-
     fbx_simple_property(QuaternionInterpolate, int, 0)
 
     fbx_simple_property(RotationOffset, aiVector3D, aiVector3D())
@@ -477,7 +440,6 @@ public:
     fbx_simple_property(Freeze, bool, false)
 
 public:
-
     const std::string& Shading() const {
         return shading;
     }
@@ -508,37 +470,31 @@ public:
         return attributes;
     }
 
-public:
-
     /** convenience method to check if the node has a Null node marker */
     bool IsNull() const;
 
 
 private:
-
     void ResolveLinks(const Element& element, const Document& doc);
 
 private:
-
     std::vector<const Material*> materials;
     std::vector<const Geometry*> geometry;
     std::vector<const NodeAttribute*> attributes;
 
     std::string shading;
     std::string culling;
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
 };
 
 /** DOM class for generic FBX textures */
 class Texture : public Object
 {
 public:
-
     Texture(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Texture();
+    virtual ~Texture();
 
 public:
-
     const std::string& Type() const {
         return type;
     }
@@ -578,7 +534,6 @@ public:
     }
 
 private:
-
     aiVector2D uvTrans;
     aiVector2D uvScaling;
 
@@ -586,7 +541,7 @@ private:
     std::string relativeFileName;
     std::string fileName;
     std::string alphaSource;
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
 
     unsigned int crop[4];
 
@@ -597,9 +552,8 @@ private:
 class LayeredTexture : public Object
 {
 public:
-
     LayeredTexture(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~LayeredTexture();
+    virtual ~LayeredTexture();
 
     //Can only be called after construction of the layered texture object due to construction flag.
     void fillTexture(const Document& doc);
@@ -644,14 +598,17 @@ public:
     {
         return texture;
     }
+
     BlendMode GetBlendMode()
     {
         return blendMode;
     }
+    
     float Alpha()
     {
         return alpha;
     }
+
 private:
     const Texture* texture;
     BlendMode blendMode;
@@ -666,12 +623,10 @@ typedef std::fbx_unordered_map<std::string, const LayeredTexture*> LayeredTextur
 class Video : public Object
 {
 public:
-
     Video(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Video();
+    virtual ~Video();
 
 public:
-
     const std::string& Type() const {
         return type;
     }
@@ -705,11 +660,10 @@ public:
     }
 
 private:
-
     std::string type;
     std::string relativeFileName;
     std::string fileName;
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
 
     uint32_t contentLength;
     uint8_t* content;
@@ -719,11 +673,8 @@ private:
 class Material : public Object
 {
 public:
-
     Material(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Material();
-
-public:
+    virtual ~Material();
 
     const std::string& GetShadingModel() const {
         return shading;
@@ -747,202 +698,14 @@ public:
     }
 
 private:
-
     std::string shading;
     bool multilayer;
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
 
     TextureMap textures;
     LayeredTextureMap layeredTextures;
 };
 
-
-/** DOM base class for all kinds of FBX geometry */
-class Geometry : public Object
-{
-public:
-
-    Geometry(uint64_t id, const Element& element, const std::string& name, const Document& doc);
-    ~Geometry();
-
-public:
-
-    /** Get the Skin attached to this geometry or NULL */
-    const Skin* DeformerSkin() const {
-        return skin;
-    }
-
-private:
-
-    const Skin* skin;
-};
-
-
-typedef std::vector<int> MatIndexArray;
-
-
-/** DOM class for FBX geometry of type "Mesh"*/
-class MeshGeometry : public Geometry
-{
-
-public:
-
-    MeshGeometry(uint64_t id, const Element& element, const std::string& name, const Document& doc);
-    ~MeshGeometry();
-
-public:
-
-    /** Get a list of all vertex points, non-unique*/
-    const std::vector<aiVector3D>& GetVertices() const {
-        return vertices;
-    }
-
-    /** Get a list of all vertex normals or an empty array if
-     *  no normals are specified. */
-    const std::vector<aiVector3D>& GetNormals() const {
-        return normals;
-    }
-
-    /** Get a list of all vertex tangents or an empty array
-     *  if no tangents are specified */
-    const std::vector<aiVector3D>& GetTangents() const {
-        return tangents;
-    }
-
-    /** Get a list of all vertex binormals or an empty array
-     *  if no binormals are specified */
-    const std::vector<aiVector3D>& GetBinormals() const {
-        return binormals;
-    }
-
-    /** Return list of faces - each entry denotes a face and specifies
-     *  how many vertices it has. Vertices are taken from the
-     *  vertex data arrays in sequential order. */
-    const std::vector<unsigned int>& GetFaceIndexCounts() const {
-        return faces;
-    }
-
-    /** Get a UV coordinate slot, returns an empty array if
-     *  the requested slot does not exist. */
-    const std::vector<aiVector2D>& GetTextureCoords(unsigned int index) const {
-        static const std::vector<aiVector2D> empty;
-        return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? empty : uvs[index];
-    }
-
-
-    /** Get a UV coordinate slot, returns an empty array if
-     *  the requested slot does not exist. */
-    std::string GetTextureCoordChannelName(unsigned int index) const {
-        return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? "" : uvNames[index];
-    }
-
-    /** Get a vertex color coordinate slot, returns an empty array if
-     *  the requested slot does not exist. */
-    const std::vector<aiColor4D>& GetVertexColors(unsigned int index) const {
-        static const std::vector<aiColor4D> empty;
-        return index >= AI_MAX_NUMBER_OF_COLOR_SETS ? empty : colors[index];
-    }
-
-
-    /** Get per-face-vertex material assignments */
-    const MatIndexArray& GetMaterialIndices() const {
-        return materials;
-    }
-
-
-    /** Convert from a fbx file vertex index (for example from a #Cluster weight) or NULL
-      * if the vertex index is not valid. */
-    const unsigned int* ToOutputVertexIndex(unsigned int in_index, unsigned int& count) const {
-        if(in_index >= mapping_counts.size()) {
-            return NULL;
-        }
-
-        ai_assert(mapping_counts.size() == mapping_offsets.size());
-        count = mapping_counts[in_index];
-
-        ai_assert(count != 0);
-        ai_assert(mapping_offsets[in_index] + count <= mappings.size());
-
-        return &mappings[mapping_offsets[in_index]];
-    }
-
-
-    /** Determine the face to which a particular output vertex index belongs.
-     *  This mapping is always unique. */
-    unsigned int FaceForVertexIndex(unsigned int in_index) const {
-        ai_assert(in_index < vertices.size());
-
-        // in the current conversion pattern this will only be needed if
-        // weights are present, so no need to always pre-compute this table
-        if (facesVertexStartIndices.empty()) {
-            facesVertexStartIndices.resize(faces.size() + 1, 0);
-
-            std::partial_sum(faces.begin(), faces.end(), facesVertexStartIndices.begin() + 1);
-            facesVertexStartIndices.pop_back();
-        }
-
-        ai_assert(facesVertexStartIndices.size() == faces.size());
-        const std::vector<unsigned int>::iterator it = std::upper_bound(
-            facesVertexStartIndices.begin(),
-            facesVertexStartIndices.end(),
-            in_index
-        );
-
-        return static_cast<unsigned int>(std::distance(facesVertexStartIndices.begin(), it - 1));
-    }
-
-public:
-
-private:
-
-    void ReadLayer(const Scope& layer);
-    void ReadLayerElement(const Scope& layerElement);
-    void ReadVertexData(const std::string& type, int index, const Scope& source);
-
-    void ReadVertexDataUV(std::vector<aiVector2D>& uv_out, const Scope& source,
-        const std::string& MappingInformationType,
-        const std::string& ReferenceInformationType);
-
-    void ReadVertexDataNormals(std::vector<aiVector3D>& normals_out, const Scope& source,
-        const std::string& MappingInformationType,
-        const std::string& ReferenceInformationType);
-
-    void ReadVertexDataColors(std::vector<aiColor4D>& colors_out, const Scope& source,
-        const std::string& MappingInformationType,
-        const std::string& ReferenceInformationType);
-
-    void ReadVertexDataTangents(std::vector<aiVector3D>& tangents_out, const Scope& source,
-        const std::string& MappingInformationType,
-        const std::string& ReferenceInformationType);
-
-    void ReadVertexDataBinormals(std::vector<aiVector3D>& binormals_out, const Scope& source,
-        const std::string& MappingInformationType,
-        const std::string& ReferenceInformationType);
-
-    void ReadVertexDataMaterials(MatIndexArray& materials_out, const Scope& source,
-        const std::string& MappingInformationType,
-        const std::string& ReferenceInformationType);
-
-private:
-
-    // cached data arrays
-    MatIndexArray materials;
-    std::vector<aiVector3D> vertices;
-    std::vector<unsigned int> faces;
-    mutable std::vector<unsigned int> facesVertexStartIndices;
-    std::vector<aiVector3D> tangents;
-    std::vector<aiVector3D> binormals;
-    std::vector<aiVector3D> normals;
-
-    std::string uvNames[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    std::vector<aiVector2D> uvs[AI_MAX_NUMBER_OF_TEXTURECOORDS];
-    std::vector<aiColor4D> colors[AI_MAX_NUMBER_OF_COLOR_SETS];
-
-    std::vector<unsigned int> mapping_counts;
-    std::vector<unsigned int> mapping_offsets;
-    std::vector<unsigned int> mappings;
-};
-
 typedef std::vector<int64_t> KeyTimeList;
 typedef std::vector<float> KeyValueList;
 
@@ -950,11 +713,8 @@ typedef std::vector<float> KeyValueList;
 class AnimationCurve : public Object
 {
 public:
-
     AnimationCurve(uint64_t id, const Element& element, const std::string& name, const Document& doc);
-    ~AnimationCurve();
-
-public:
+    virtual ~AnimationCurve();
 
     /** get list of keyframe positions (time).
      *  Invariant: |GetKeys()| > 0 */
@@ -979,7 +739,6 @@ public:
     }
 
 private:
-
     KeyTimeList keys;
     KeyValueList values;
     std::vector<float> attributes;
@@ -994,16 +753,13 @@ typedef std::map<std::string, const AnimationCurve*> AnimationCurveMap;
 class AnimationCurveNode : public Object
 {
 public:
-
-    /* the optional whitelist specifies a list of property names for which the caller
+    /* the optional white list specifies a list of property names for which the caller
     wants animations for. If the curve node does not match one of these, std::range_error
     will be thrown. */
     AnimationCurveNode(uint64_t id, const Element& element, const std::string& name, const Document& doc,
         const char* const * target_prop_whitelist = NULL, size_t whitelist_size = 0);
 
-    ~AnimationCurveNode();
-
-public:
+    virtual ~AnimationCurveNode();
 
     const PropertyTable& Props() const {
         ai_assert(props.get());
@@ -1034,9 +790,8 @@ public:
     }
 
 private:
-
     const Object* target;
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
     mutable AnimationCurveMap curves;
 
     std::string prop;
@@ -1050,26 +805,21 @@ typedef std::vector<const AnimationCurveNode*> AnimationCurveNodeList;
 class AnimationLayer : public Object
 {
 public:
-
-
     AnimationLayer(uint64_t id, const Element& element, const std::string& name, const Document& doc);
-    ~AnimationLayer();
-
-public:
+    virtual ~AnimationLayer();
 
     const PropertyTable& Props() const {
         ai_assert(props.get());
         return *props.get();
     }
 
-    /* the optional whitelist specifies a list of property names for which the caller
+    /* the optional white list specifies a list of property names for which the caller
     wants animations for. Curves not matching this list will not be added to the
     animation layer. */
     AnimationCurveNodeList Nodes(const char* const * target_prop_whitelist = NULL, size_t whitelist_size = 0) const;
 
 private:
-
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
     const Document& doc;
 };
 
@@ -1081,32 +831,26 @@ typedef std::vector<const AnimationLayer*> AnimationLayerList;
 class AnimationStack : public Object
 {
 public:
-
     AnimationStack(uint64_t id, const Element& element, const std::string& name, const Document& doc);
-    ~AnimationStack();
+    virtual ~AnimationStack();
 
 public:
-
     fbx_simple_property(LocalStart, int64_t, 0L)
     fbx_simple_property(LocalStop, int64_t, 0L)
     fbx_simple_property(ReferenceStart, int64_t, 0L)
     fbx_simple_property(ReferenceStop, int64_t, 0L)
 
-
-
     const PropertyTable& Props() const {
         ai_assert(props.get());
         return *props.get();
     }
 
-
     const AnimationLayerList& Layers() const {
         return layers;
     }
 
 private:
-
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
     AnimationLayerList layers;
 };
 
@@ -1115,11 +859,8 @@ private:
 class Deformer : public Object
 {
 public:
-
     Deformer(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Deformer();
-
-public:
+    virtual ~Deformer();
 
     const PropertyTable& Props() const {
         ai_assert(props.get());
@@ -1127,8 +868,7 @@ public:
     }
 
 private:
-
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
 };
 
 typedef std::vector<float> WeightArray;
@@ -1139,11 +879,8 @@ typedef std::vector<unsigned int> WeightIndexArray;
 class Cluster : public Deformer
 {
 public:
-
     Cluster(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Cluster();
-
-public:
+    virtual ~Cluster();
 
     /** get the list of deformer weights associated with this cluster.
      *  Use #GetIndices() to get the associated vertices. Both arrays
@@ -1173,7 +910,6 @@ public:
     }
 
 private:
-
     WeightArray weights;
     WeightIndexArray indices;
 
@@ -1189,34 +925,26 @@ private:
 class Skin : public Deformer
 {
 public:
-
     Skin(uint64_t id, const Element& element, const Document& doc, const std::string& name);
-    ~Skin();
-
-public:
+    virtual ~Skin();
 
     float DeformAccuracy() const {
         return accuracy;
     }
 
-
     const std::vector<const Cluster*>& Clusters() const {
         return clusters;
     }
 
 private:
-
     float accuracy;
     std::vector<const Cluster*> clusters;
 };
 
-
-
 /** Represents a link between two FBX objects. */
 class Connection
 {
 public:
-
     Connection(uint64_t insertionOrder,  uint64_t src, uint64_t dest, const std::string& prop, const Document& doc);
     ~Connection();
 
@@ -1242,6 +970,8 @@ public:
     }
 
     int CompareTo(const Connection* c) const {
+        ai_assert( NULL != c );
+
         // note: can't subtract because this would overflow uint64_t
         if(InsertionOrder() > c->InsertionOrder()) {
             return 1;
@@ -1253,11 +983,12 @@ public:
     }
 
     bool Compare(const Connection* c) const {
+        ai_assert( NULL != c );
+
         return InsertionOrder() < c->InsertionOrder();
     }
 
 public:
-
     uint64_t insertionOrder;
     const std::string prop;
 
@@ -1265,17 +996,16 @@ public:
     const Document& doc;
 };
 
-
-    // XXX again, unique_ptr would be useful. shared_ptr is too
-    // bloated since the objects have a well-defined single owner
-    // during their entire lifetime (Document). FBX files have
-    // up to many thousands of objects (most of which we never use),
-    // so the memory overhead for them should be kept at a minimum.
-    typedef std::map<uint64_t, LazyObject*> ObjectMap;
-    typedef std::fbx_unordered_map<std::string, boost::shared_ptr<const PropertyTable> > PropertyTemplateMap;
+// XXX again, unique_ptr would be useful. shared_ptr is too
+// bloated since the objects have a well-defined single owner
+// during their entire lifetime (Document). FBX files have
+// up to many thousands of objects (most of which we never use),
+// so the memory overhead for them should be kept at a minimum.
+typedef std::map<uint64_t, LazyObject*> ObjectMap;
+typedef std::fbx_unordered_map<std::string, std::shared_ptr<const PropertyTable> > PropertyTemplateMap;
 
 
-    typedef std::multimap<uint64_t, const Connection*> ConnectionMap;
+typedef std::multimap<uint64_t, const Connection*> ConnectionMap;
 
 
 /** DOM class for global document settings, a single instance per document can
@@ -1283,12 +1013,9 @@ public:
 class FileGlobalSettings
 {
 public:
-
-    FileGlobalSettings(const Document& doc, boost::shared_ptr<const PropertyTable> props);
+    FileGlobalSettings(const Document& doc, std::shared_ptr<const PropertyTable> props);
     ~FileGlobalSettings();
 
-public:
-
     const PropertyTable& Props() const {
         ai_assert(props.get());
         return *props.get();
@@ -1298,7 +1025,6 @@ public:
         return doc;
     }
 
-
     fbx_simple_property(UpAxis, int, 1)
     fbx_simple_property(UpAxisSign, int, 1)
     fbx_simple_property(FrontAxis, int, 2)
@@ -1338,10 +1064,8 @@ public:
     fbx_simple_property(TimeSpanStop, uint64_t, 0L)
     fbx_simple_property(CustomFrameRate, float, -1.0f)
 
-
 private:
-
-    boost::shared_ptr<const PropertyTable> props;
+    std::shared_ptr<const PropertyTable> props;
     const Document& doc;
 };
 
@@ -1352,12 +1076,9 @@ private:
 class Document
 {
 public:
-
     Document(const Parser& parser, const ImportSettings& settings);
     ~Document();
 
-public:
-
     LazyObject* GetObject(uint64_t id) const;
 
     bool IsBinary() const {
@@ -1372,7 +1093,7 @@ public:
         return creator;
     }
 
-    // elements (in this order): Uear, Month, Day, Hour, Second, Millisecond
+    // elements (in this order): Year, Month, Day, Hour, Second, Millisecond
     const unsigned int* CreationTimeStamp() const {
         return creationTimeStamp;
     }
@@ -1423,7 +1144,6 @@ public:
     const std::vector<const AnimationStack*>& AnimationStacks() const;
 
 private:
-
     std::vector<const Connection*> GetConnectionsSequenced(uint64_t id, const ConnectionMap&) const;
     std::vector<const Connection*> GetConnectionsSequenced(uint64_t id, bool is_src,
         const ConnectionMap&,
@@ -1431,7 +1151,6 @@ private:
         size_t count) const;
 
 private:
-
     void ReadHeader();
     void ReadObjects();
     void ReadPropertyTemplates();
@@ -1439,7 +1158,6 @@ private:
     void ReadGlobalSettings();
 
 private:
-
     const ImportSettings& settings;
 
     ObjectMap objects;
@@ -1456,10 +1174,10 @@ private:
     std::vector<uint64_t> animationStacks;
     mutable std::vector<const AnimationStack*> animationStacksResolved;
 
-    boost::scoped_ptr<FileGlobalSettings> globals;
+    std::unique_ptr<FileGlobalSettings> globals;
 };
 
-}
-}
+} // Namespace FBX
+} // Namespace Assimp
 
-#endif
+#endif // INCLUDED_AI_FBX_DOCUMENT_H

code/FBXDocumentUtil.cpp

@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXUtil.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
-#include <boost/make_shared.hpp>
+
 
 namespace Assimp {
 namespace FBX {
@@ -96,14 +96,14 @@ void DOMWarning(const std::string& message, const Element* element /*= NULL*/)
 
 // ------------------------------------------------------------------------------------------------
 // fetch a property table and the corresponding property template
-boost::shared_ptr<const PropertyTable> GetPropertyTable(const Document& doc,
+std::shared_ptr<const PropertyTable> GetPropertyTable(const Document& doc,
     const std::string& templateName,
     const Element &element,
     const Scope& sc,
     bool no_warn /*= false*/)
 {
     const Element* const Properties70 = sc["Properties70"];
-    boost::shared_ptr<const PropertyTable> templateProps = boost::shared_ptr<const PropertyTable>(
+    std::shared_ptr<const PropertyTable> templateProps = std::shared_ptr<const PropertyTable>(
         static_cast<const PropertyTable*>(NULL));
 
     if(templateName.length()) {
@@ -121,10 +121,10 @@ boost::shared_ptr<const PropertyTable> GetPropertyTable(const Document& doc,
             return templateProps;
         }
         else {
-            return boost::make_shared<const PropertyTable>();
+            return std::make_shared<const PropertyTable>();
         }
     }
-    return boost::make_shared<const PropertyTable>(*Properties70,templateProps);
+    return std::make_shared<const PropertyTable>(*Properties70,templateProps);
 }
 } // !Util
 } // !FBX

code/FBXDocumentUtil.h

@@ -46,7 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../include/assimp/defs.h"
 #include <string>
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "FBXDocument.h"
 
 struct Token;
@@ -67,7 +67,7 @@ void DOMWarning(const std::string& message, const Element* element = NULL);
 
 
 // fetch a property table and the corresponding property template
-boost::shared_ptr<const PropertyTable> GetPropertyTable(const Document& doc,
+std::shared_ptr<const PropertyTable> GetPropertyTable(const Document& doc,
     const std::string& templateName,
     const Element &element,
     const Scope& sc,

code/FBXImporter.cpp

@@ -12,7 +12,7 @@ following conditions are met:
 * Redistributions of source code must retain the above
   copyright notice, this list of conditions and the
   following disclaimer.
-
+r
 * Redistributions in binary form must reproduce the above
   copyright notice, this list of conditions and the
   following disclaimer in the documentation and/or other
@@ -46,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <exception>
 #include <iterator>
-#include <boost/tuple/tuple.hpp>
 
 #include "FBXImporter.h"
 
@@ -86,7 +85,8 @@ static const aiImporterDesc desc = {
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by #Importer
 FBXImporter::FBXImporter()
-{}
+{
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
@@ -104,7 +104,7 @@ bool FBXImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool
     }
 
     else if ((!extension.length() || checkSig) && pIOHandler)   {
-        // at least ascii FBX files usually have a 'FBX' somewhere in their head
+        // at least ASCII-FBX files usually have a 'FBX' somewhere in their head
         const char* tokens[] = {"fbx"};
         return SearchFileHeaderForToken(pIOHandler,pFile,tokens,1);
     }
@@ -141,7 +141,7 @@ void FBXImporter::SetupProperties(const Importer* pImp)
 void FBXImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    boost::scoped_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
+    std::unique_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
     if (!stream) {
         ThrowException("Could not open file for reading");
     }

code/FBXImporter.h

@@ -51,12 +51,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp    {
 
-    // TinyFormatter.h
-    namespace Formatter {
-        template <typename T,typename TR, typename A> class basic_formatter;
-        typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format;
-    }
-
+// TinyFormatter.h
+namespace Formatter {
+    template <typename T,typename TR, typename A> class basic_formatter;
+    typedef class basic_formatter< char, std::char_traits<char>, std::allocator<char> > format;
+}
 
 // -------------------------------------------------------------------------------------------
 /** Load the Autodesk FBX file format.
@@ -68,10 +67,7 @@ class FBXImporter : public BaseImporter, public LogFunctions<FBXImporter>
 {
 public:
     FBXImporter();
-    ~FBXImporter();
-
-
-public:
+    virtual ~FBXImporter();
 
     // --------------------
     bool CanRead( const std::string& pFile,
@@ -94,12 +90,7 @@ protected:
     );
 
 private:
-
-
-private:
-
     FBX::ImportSettings settings;
-
 }; // !class FBXImporter
 
 } // end of namespace Assimp

code/FBXMaterial.cpp

@@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
 #include "ByteSwapper.h"
-#include <boost/foreach.hpp>
 
 namespace Assimp {
 namespace FBX {
@@ -96,7 +95,7 @@ Material::Material(uint64_t id, const Element& element, const Document& doc, con
 
     // resolve texture links
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
 
         // texture link to properties, not objects
         if (!con->PropertyName().length()) {
@@ -205,7 +204,7 @@ Texture::Texture(uint64_t id, const Element& element, const Document& doc, const
     // resolve video links
     if(doc.Settings().readTextures) {
         const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID());
-        BOOST_FOREACH(const Connection* con, conns) {
+        for(const Connection* con : conns) {
             const Object* const ob = con->SourceObject();
             if(!ob) {
                 DOMWarning("failed to read source object for texture link, ignoring",&element);

code/FBXMeshGeometry.cpp

@@ -46,19 +46,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <functional>
 
-#include "FBXParser.h"
+#include "FBXMeshGeometry.h"
 #include "FBXDocument.h"
 #include "FBXImporter.h"
 #include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
-#include <boost/foreach.hpp>
 
 
 namespace Assimp {
 namespace FBX {
 
-    using namespace Util;
-
+using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
 Geometry::Geometry(uint64_t id, const Element& element, const std::string& name, const Document& doc)
@@ -66,7 +64,7 @@ Geometry::Geometry(uint64_t id, const Element& element, const std::string& name,
     , skin()
 {
     const std::vector<const Connection*>& conns = doc.GetConnectionsByDestinationSequenced(ID(),"Deformer");
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
         const Skin* const sk = ProcessSimpleConnection<Skin>(*con, false, "Skin -> Geometry", element);
         if(sk) {
             skin = sk;
@@ -82,6 +80,9 @@ Geometry::~Geometry()
 
 }
 
+const Skin* Geometry::DeformerSkin() const {
+    return skin;
+}
 
 
 // ------------------------------------------------------------------------------------------------
@@ -128,7 +129,7 @@ MeshGeometry::MeshGeometry(uint64_t id, const Element& element, const std::strin
     // generate output vertices, computing an adjacency table to
     // preserve the mapping from fbx indices to *this* indexing.
     unsigned int count = 0;
-    BOOST_FOREACH(int index, tempFaces) {
+    for(int index : tempFaces) {
         const int absi = index < 0 ? (-index - 1) : index;
         if(static_cast<size_t>(absi) >= vertex_count) {
             DOMError("polygon vertex index out of range",&PolygonVertexIndex);
@@ -154,7 +155,7 @@ MeshGeometry::MeshGeometry(uint64_t id, const Element& element, const std::strin
     }
 
     cursor = 0;
-    BOOST_FOREACH(int index, tempFaces) {
+    for(int index : tempFaces) {
         const int absi = index < 0 ? (-index - 1) : index;
         mappings[mapping_offsets[absi] + mapping_counts[absi]++] = cursor++;
     }
@@ -182,14 +183,93 @@ MeshGeometry::MeshGeometry(uint64_t id, const Element& element, const std::strin
     }
 }
 
-
 // ------------------------------------------------------------------------------------------------
 MeshGeometry::~MeshGeometry()
 {
 
 }
 
+// ------------------------------------------------------------------------------------------------
+const std::vector<aiVector3D>& MeshGeometry::GetVertices() const {
+    return vertices;
+}
+
+// ------------------------------------------------------------------------------------------------
+const std::vector<aiVector3D>& MeshGeometry::GetNormals() const {
+    return normals;
+}
+
+// ------------------------------------------------------------------------------------------------
+const std::vector<aiVector3D>& MeshGeometry::GetTangents() const {
+    return tangents;
+}
 
+// ------------------------------------------------------------------------------------------------
+const std::vector<aiVector3D>& MeshGeometry::GetBinormals() const {
+    return binormals;
+}
+
+// ------------------------------------------------------------------------------------------------
+const std::vector<unsigned int>& MeshGeometry::GetFaceIndexCounts() const {
+    return faces;
+}
+
+// ------------------------------------------------------------------------------------------------
+const std::vector<aiVector2D>& MeshGeometry::GetTextureCoords( unsigned int index ) const {
+    static const std::vector<aiVector2D> empty;
+    return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? empty : uvs[ index ];
+}
+
+std::string MeshGeometry::GetTextureCoordChannelName( unsigned int index ) const {
+    return index >= AI_MAX_NUMBER_OF_TEXTURECOORDS ? "" : uvNames[ index ];
+}
+
+const std::vector<aiColor4D>& MeshGeometry::GetVertexColors( unsigned int index ) const {
+    static const std::vector<aiColor4D> empty;
+    return index >= AI_MAX_NUMBER_OF_COLOR_SETS ? empty : colors[ index ];
+}
+
+const MatIndexArray& MeshGeometry::GetMaterialIndices() const {
+    return materials;
+}
+
+// ------------------------------------------------------------------------------------------------
+const unsigned int* MeshGeometry::ToOutputVertexIndex( unsigned int in_index, unsigned int& count ) const {
+    if ( in_index >= mapping_counts.size() ) {
+        return NULL;
+    }
+
+    ai_assert( mapping_counts.size() == mapping_offsets.size() );
+    count = mapping_counts[ in_index ];
+
+    ai_assert( count != 0 );
+    ai_assert( mapping_offsets[ in_index ] + count <= mappings.size() );
+
+    return &mappings[ mapping_offsets[ in_index ] ];
+}
+
+// ------------------------------------------------------------------------------------------------
+unsigned int MeshGeometry::FaceForVertexIndex( unsigned int in_index ) const {
+    ai_assert( in_index < vertices.size() );
+
+    // in the current conversion pattern this will only be needed if
+    // weights are present, so no need to always pre-compute this table
+    if ( facesVertexStartIndices.empty() ) {
+        facesVertexStartIndices.resize( faces.size() + 1, 0 );
+
+        std::partial_sum( faces.begin(), faces.end(), facesVertexStartIndices.begin() + 1 );
+        facesVertexStartIndices.pop_back();
+    }
+
+    ai_assert( facesVertexStartIndices.size() == faces.size() );
+    const std::vector<unsigned int>::iterator it = std::upper_bound(
+        facesVertexStartIndices.begin(),
+        facesVertexStartIndices.end(),
+        in_index
+        );
+
+    return static_cast< unsigned int >( std::distance( facesVertexStartIndices.begin(), it - 1 ) );
+}
 
 // ------------------------------------------------------------------------------------------------
 void MeshGeometry::ReadLayer(const Scope& layer)
@@ -273,7 +353,7 @@ void MeshGeometry::ReadVertexData(const std::string& type, int index, const Scop
         // sometimes, there will be only negative entries. Drop the material
         // layer in such a case (I guess it means a default material should
         // be used). This is what the converter would do anyway, and it
-        // avoids loosing the material if there are more material layers
+        // avoids losing the material if there are more material layers
         // coming of which at least one contains actual data (did observe
         // that with one test file).
         const size_t count_neg = std::count_if(temp_materials.begin(),temp_materials.end(),std::bind2nd(std::less<int>(),0));
@@ -413,7 +493,7 @@ void ResolveVertexDataArray(std::vector<T>& data_out, const Scope& source,
         }
 
         unsigned int next = 0;
-        BOOST_FOREACH(int i, uvIndices) {
+        for(int i : uvIndices) {
 			if (static_cast<size_t>(i) >= tempData.size()) {
                 DOMError("index out of range",&GetRequiredElement(source,indexDataElementName));
             }

code/FBXMeshGeometry.h

@@ -0,0 +1,180 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2016, assimp team
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the
+following conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+----------------------------------------------------------------------
+*/
+
+/** @file  FBXImporter.h
+*  @brief Declaration of the FBX main importer class
+*/
+#ifndef INCLUDED_AI_FBX_MESHGEOMETRY_H
+#define INCLUDED_AI_FBX_MESHGEOMETRY_H
+
+#include "FBXParser.h"
+#include "FBXDocument.h"
+
+namespace Assimp {
+namespace FBX {
+
+/** 
+ *  DOM base class for all kinds of FBX geometry 
+ */
+class Geometry : public Object
+{
+public:
+    Geometry( uint64_t id, const Element& element, const std::string& name, const Document& doc );
+    virtual ~Geometry();
+
+    /** Get the Skin attached to this geometry or NULL */
+    const Skin* DeformerSkin() const;
+
+private:
+    const Skin* skin;
+};
+
+
+typedef std::vector<int> MatIndexArray;
+
+
+/** 
+ *  DOM class for FBX geometry of type "Mesh"
+ */
+class MeshGeometry : public Geometry
+{
+public:
+    /** The class constructor */
+    MeshGeometry( uint64_t id, const Element& element, const std::string& name, const Document& doc );
+    
+    /** The class destructor */
+    virtual ~MeshGeometry();
+
+    /** Get a list of all vertex points, non-unique*/
+    const std::vector<aiVector3D>& GetVertices() const;
+
+    /** Get a list of all vertex normals or an empty array if
+    *  no normals are specified. */
+    const std::vector<aiVector3D>& GetNormals() const;
+
+    /** Get a list of all vertex tangents or an empty array
+    *  if no tangents are specified */
+    const std::vector<aiVector3D>& GetTangents() const;
+
+    /** Get a list of all vertex binormals or an empty array
+    *  if no binormals are specified */
+    const std::vector<aiVector3D>& GetBinormals() const;
+
+    /** Return list of faces - each entry denotes a face and specifies
+    *  how many vertices it has. Vertices are taken from the
+    *  vertex data arrays in sequential order. */
+    const std::vector<unsigned int>& GetFaceIndexCounts() const;
+
+    /** Get a UV coordinate slot, returns an empty array if
+    *  the requested slot does not exist. */
+    const std::vector<aiVector2D>& GetTextureCoords( unsigned int index ) const;
+
+    /** Get a UV coordinate slot, returns an empty array if
+    *  the requested slot does not exist. */
+    std::string GetTextureCoordChannelName( unsigned int index ) const;
+
+    /** Get a vertex color coordinate slot, returns an empty array if
+    *  the requested slot does not exist. */
+    const std::vector<aiColor4D>& GetVertexColors( unsigned int index ) const;
+
+    /** Get per-face-vertex material assignments */
+    const MatIndexArray& GetMaterialIndices() const;
+
+    /** Convert from a fbx file vertex index (for example from a #Cluster weight) or NULL
+    * if the vertex index is not valid. */
+    const unsigned int* ToOutputVertexIndex( unsigned int in_index, unsigned int& count ) const;
+
+    /** Determine the face to which a particular output vertex index belongs.
+    *  This mapping is always unique. */
+    unsigned int FaceForVertexIndex( unsigned int in_index ) const;
+
+private:
+    void ReadLayer( const Scope& layer );
+    void ReadLayerElement( const Scope& layerElement );
+    void ReadVertexData( const std::string& type, int index, const Scope& source );
+
+    void ReadVertexDataUV( std::vector<aiVector2D>& uv_out, const Scope& source,
+        const std::string& MappingInformationType,
+        const std::string& ReferenceInformationType );
+
+    void ReadVertexDataNormals( std::vector<aiVector3D>& normals_out, const Scope& source,
+        const std::string& MappingInformationType,
+        const std::string& ReferenceInformationType );
+
+    void ReadVertexDataColors( std::vector<aiColor4D>& colors_out, const Scope& source,
+        const std::string& MappingInformationType,
+        const std::string& ReferenceInformationType );
+
+    void ReadVertexDataTangents( std::vector<aiVector3D>& tangents_out, const Scope& source,
+        const std::string& MappingInformationType,
+        const std::string& ReferenceInformationType );
+
+    void ReadVertexDataBinormals( std::vector<aiVector3D>& binormals_out, const Scope& source,
+        const std::string& MappingInformationType,
+        const std::string& ReferenceInformationType );
+
+    void ReadVertexDataMaterials( MatIndexArray& materials_out, const Scope& source,
+        const std::string& MappingInformationType,
+        const std::string& ReferenceInformationType );
+
+private:
+    // cached data arrays
+    MatIndexArray materials;
+    std::vector<aiVector3D> vertices;
+    std::vector<unsigned int> faces;
+    mutable std::vector<unsigned int> facesVertexStartIndices;
+    std::vector<aiVector3D> tangents;
+    std::vector<aiVector3D> binormals;
+    std::vector<aiVector3D> normals;
+
+    std::string uvNames[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+    std::vector<aiVector2D> uvs[ AI_MAX_NUMBER_OF_TEXTURECOORDS ];
+    std::vector<aiColor4D> colors[ AI_MAX_NUMBER_OF_COLOR_SETS ];
+
+    std::vector<unsigned int> mapping_counts;
+    std::vector<unsigned int> mapping_offsets;
+    std::vector<unsigned int> mappings;
+};
+
+}
+}
+
+#endif // INCLUDED_AI_FBX_MESHGEOMETRY_H
+

code/FBXModel.cpp

@@ -45,17 +45,17 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 
 #include "FBXParser.h"
+#include "FBXMeshGeometry.h"
 #include "FBXDocument.h"
 #include "FBXImporter.h"
 #include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
-#include <boost/foreach.hpp>
 
 namespace Assimp {
 namespace FBX {
 
-    using namespace Util;
+using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
 Model::Model(uint64_t id, const Element& element, const Document& doc, const std::string& name)
@@ -97,7 +97,7 @@ void Model::ResolveLinks(const Element& element, const Document& doc)
     materials.reserve(conns.size());
     geometry.reserve(conns.size());
     attributes.reserve(conns.size());
-    BOOST_FOREACH(const Connection* con, conns) {
+    for(const Connection* con : conns) {
 
         // material and geometry links should be Object-Object connections
         if (con->PropertyName().length()) {
@@ -138,7 +138,7 @@ void Model::ResolveLinks(const Element& element, const Document& doc)
 bool Model::IsNull() const
 {
     const std::vector<const NodeAttribute*>& attrs = GetAttributes();
-    BOOST_FOREACH(const NodeAttribute* att, attrs) {
+    for(const NodeAttribute* att : attrs) {
 
         const Null* null_tag = dynamic_cast<const Null*>(att);
         if(null_tag) {

code/FBXNodeAttribute.cpp

@@ -58,7 +58,8 @@ namespace FBX {
 
 // ------------------------------------------------------------------------------------------------
 NodeAttribute::NodeAttribute(uint64_t id, const Element& element, const Document& doc, const std::string& name)
-    : Object(id,element,name)
+: Object(id,element,name)
+, props()
 {
     const Scope& sc = GetRequiredScope(element);
 

code/FBXParser.cpp

@@ -58,9 +58,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "ParsingUtils.h"
 #include "fast_atof.h"
-#include <boost/foreach.hpp>
 #include "ByteSwapper.h"
 
+#include <iostream>
+
 using namespace Assimp;
 using namespace Assimp::FBX;
 
@@ -206,7 +207,7 @@ Scope::Scope(Parser& parser,bool topLevel)
 // ------------------------------------------------------------------------------------------------
 Scope::~Scope()
 {
-    BOOST_FOREACH(ElementMap::value_type& v, elements) {
+    for(ElementMap::value_type& v : elements) {
         delete v.second;
     }
 }
@@ -611,7 +612,7 @@ void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const cha
 // read an array of float3 tuples
 void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
 
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
@@ -653,6 +654,13 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
                     static_cast<float>(d[1]),
                     static_cast<float>(d[2])));
             }
+            // for debugging
+            /*for ( size_t i = 0; i < out.size(); i++ ) {
+                aiVector3D vec3( out[ i ] );
+                std::stringstream stream;
+                stream << " vec3.x = " << vec3.x << " vec3.y = " << vec3.y << " vec3.z = " << vec3.z << std::endl;
+                DefaultLogger::get()->info( stream.str() );
+            }*/
         }
         else if (type == 'f') {
             const float* f = reinterpret_cast<const float*>(&buff[0]);
@@ -692,7 +700,7 @@ void ParseVectorDataArray(std::vector<aiVector3D>& out, const Element& el)
 // read an array of color4 tuples
 void ParseVectorDataArray(std::vector<aiColor4D>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
         ParseError("unexpected empty element",&el);
@@ -771,7 +779,7 @@ void ParseVectorDataArray(std::vector<aiColor4D>& out, const Element& el)
 // read an array of float2 tuples
 void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
         ParseError("unexpected empty element",&el);
@@ -847,7 +855,7 @@ void ParseVectorDataArray(std::vector<aiVector2D>& out, const Element& el)
 // read an array of ints
 void ParseVectorDataArray(std::vector<int>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
         ParseError("unexpected empty element",&el);
@@ -905,7 +913,7 @@ void ParseVectorDataArray(std::vector<int>& out, const Element& el)
 // read an array of floats
 void ParseVectorDataArray(std::vector<float>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
         ParseError("unexpected empty element",&el);
@@ -967,7 +975,7 @@ void ParseVectorDataArray(std::vector<float>& out, const Element& el)
 // read an array of uints
 void ParseVectorDataArray(std::vector<unsigned int>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
         ParseError("unexpected empty element",&el);
@@ -1032,7 +1040,7 @@ void ParseVectorDataArray(std::vector<unsigned int>& out, const Element& el)
 // read an array of uint64_ts
 void ParseVectorDataArray(std::vector<uint64_t>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if(tok.empty()) {
         ParseError("unexpected empty element",&el);
@@ -1090,7 +1098,7 @@ void ParseVectorDataArray(std::vector<uint64_t>& out, const Element& el)
 // read an array of int64_ts
 void ParseVectorDataArray(std::vector<int64_t>& out, const Element& el)
 {
-    out.clear();
+    out.resize( 0 );
     const TokenList& tok = el.Tokens();
     if (tok.empty()) {
         ParseError("unexpected empty element", &el);

code/FBXParser.h

@@ -44,14 +44,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_PARSER_H
 #define INCLUDED_AI_FBX_PARSER_H
 
-#include <vector>
-#include <map>
-#include <string>
-#include <utility>
 #include <stdint.h>
-
-#include <boost/shared_ptr.hpp>
-#include <boost/scoped_ptr.hpp>
+#include <map>
+#include <memory>
 #include "LogAux.h"
 
 #include "FBXCompileConfig.h"
@@ -60,15 +55,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace FBX {
 
-    class Scope;
-    class Parser;
-    class Element;
+class Scope;
+class Parser;
+class Element;
 
-    // XXX should use C++11's unique_ptr - but assimp's need to keep working with 03
-    typedef std::vector< Scope* > ScopeList;
-    typedef std::fbx_unordered_multimap< std::string, Element* > ElementMap;
+// XXX should use C++11's unique_ptr - but assimp's need to keep working with 03
+typedef std::vector< Scope* > ScopeList;
+typedef std::fbx_unordered_multimap< std::string, Element* > ElementMap;
 
-    typedef std::pair<ElementMap::const_iterator,ElementMap::const_iterator> ElementCollection;
+typedef std::pair<ElementMap::const_iterator,ElementMap::const_iterator> ElementCollection;
 
 #   define new_Scope new Scope
 #   define new_Element new Element
@@ -110,7 +105,7 @@ private:
 
     const Token& key_token;
     TokenList tokens;
-    boost::scoped_ptr<Scope> compound;
+    std::unique_ptr<Scope> compound;
 };
 
 
@@ -167,7 +162,6 @@ public:
     ~Parser();
 
 public:
-
     const Scope& GetRootScope() const {
         return *root.get();
     }
@@ -178,7 +172,6 @@ public:
     }
 
 private:
-
     friend class Scope;
     friend class Element;
 
@@ -188,14 +181,12 @@ private:
     TokenPtr CurrentToken() const;
 
 
-
 private:
-
     const TokenList& tokens;
 
     TokenPtr last, current;
     TokenList::const_iterator cursor;
-    boost::scoped_ptr<Scope> root;
+    std::unique_ptr<Scope> root;
 
     const bool is_binary;
 };

code/FBXProperties.cpp

@@ -49,7 +49,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXDocument.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
-#include <boost/foreach.hpp>
 
 namespace Assimp {
 namespace FBX {
@@ -140,12 +139,12 @@ PropertyTable::PropertyTable()
 
 
 // ------------------------------------------------------------------------------------------------
-PropertyTable::PropertyTable(const Element& element, boost::shared_ptr<const PropertyTable> templateProps)
+PropertyTable::PropertyTable(const Element& element, std::shared_ptr<const PropertyTable> templateProps)
 : templateProps(templateProps)
 , element(&element)
 {
     const Scope& scope = GetRequiredScope(element);
-    BOOST_FOREACH(const ElementMap::value_type& v, scope.Elements()) {
+    for(const ElementMap::value_type& v : scope.Elements()) {
         if(v.first != "P") {
             DOMWarning("expected only P elements in property table",v.second);
             continue;
@@ -171,7 +170,7 @@ PropertyTable::PropertyTable(const Element& element, boost::shared_ptr<const Pro
 // ------------------------------------------------------------------------------------------------
 PropertyTable::~PropertyTable()
 {
-    BOOST_FOREACH(PropertyMap::value_type& v, props) {
+    for(PropertyMap::value_type& v : props) {
         delete v.second;
     }
 }
@@ -209,7 +208,7 @@ DirectPropertyMap PropertyTable::GetUnparsedProperties() const
     DirectPropertyMap result;
 
     // Loop through all the lazy properties (which is all the properties)
-    BOOST_FOREACH(const LazyPropertyMap::value_type& element, lazyProps) {
+    for(const LazyPropertyMap::value_type& element : lazyProps) {
 
         // Skip parsed properties
         if (props.end() != props.find(element.first)) continue;
@@ -217,7 +216,7 @@ DirectPropertyMap PropertyTable::GetUnparsedProperties() const
         // Read the element's value.
         // Wrap the naked pointer (since the call site is required to acquire ownership)
         // std::unique_ptr from C++11 would be preferred both as a wrapper and a return value.
-        boost::shared_ptr<Property> prop = boost::shared_ptr<Property>(ReadTypedProperty(*element.second));
+        std::shared_ptr<Property> prop = std::shared_ptr<Property>(ReadTypedProperty(*element.second));
 
         // Element could not be read. Skip it.
         if (!prop) continue;

code/FBXProperties.h

@@ -45,9 +45,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_FBX_PROPERTIES_H
 
 #include <map>
-#include <string>
 #include "FBXCompileConfig.h"
-#include <boost/shared_ptr.hpp>
+#include <memory>
 
 namespace Assimp {
 namespace FBX {
@@ -66,15 +65,12 @@ namespace FBX {
 class Property
 {
 protected:
-
     Property();
 
 public:
-
     virtual ~Property();
 
 public:
-
     template <typename T>
     const T* As() const {
         return dynamic_cast<const T*>(this);
@@ -86,14 +82,12 @@ template<typename T>
 class TypedProperty : public Property
 {
 public:
-
     explicit TypedProperty(const T& value)
         : value(value)
     {
     }
 
 public:
-
     const T& Value() const {
         return value;
     }
@@ -103,23 +97,22 @@ private:
 };
 
 
-typedef std::fbx_unordered_map<std::string,boost::shared_ptr<Property> > DirectPropertyMap;
+typedef std::fbx_unordered_map<std::string,std::shared_ptr<Property> > DirectPropertyMap;
 typedef std::fbx_unordered_map<std::string,const Property*> PropertyMap;
 typedef std::fbx_unordered_map<std::string,const Element*> LazyPropertyMap;
 
-/** Represents a property table as can be found in the newer FBX files (Properties60, Properties70)*/
+/** 
+ *  Represents a property table as can be found in the newer FBX files (Properties60, Properties70)
+ */
 class PropertyTable
 {
 public:
-
     // in-memory property table with no source element
     PropertyTable();
-
-    PropertyTable(const Element& element, boost::shared_ptr<const PropertyTable> templateProps);
+    PropertyTable(const Element& element, std::shared_ptr<const PropertyTable> templateProps);
     ~PropertyTable();
 
 public:
-
     const Property* Get(const std::string& name) const;
 
     // PropertyTable's need not be coupled with FBX elements so this can be NULL
@@ -134,10 +127,9 @@ public:
     DirectPropertyMap GetUnparsedProperties() const;
 
 private:
-
     LazyPropertyMap lazyProps;
     mutable PropertyMap props;
-    const boost::shared_ptr<const PropertyTable> templateProps;
+    const std::shared_ptr<const PropertyTable> templateProps;
     const Element* const element;
 };
 
@@ -188,4 +180,4 @@ inline T PropertyGet(const PropertyTable& in, const std::string& name,
 } //! FBX
 } //! Assimp
 
-#endif //
+#endif // INCLUDED_AI_FBX_PROPERTIES_H

code/FBXTokenizer.h

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_TOKENIZER_H
 #define INCLUDED_AI_FBX_TOKENIZER_H
 
-#include <boost/shared_ptr.hpp>
+#include <memory>
 #include "FBXCompileConfig.h"
 #include "../include/assimp/ai_assert.h"
 #include <vector>

code/FBXUtil.h

@@ -74,7 +74,7 @@ const char* TokenTypeString(TokenType t);
  *  @param prefix Message prefix to be preprended to the location info.
  *  @param text Message text
  *  @param line Line index, 1-based
- *  @param column Colum index, 1-based
+ *  @param column Column index, 1-based
  *  @return A string of the following format: {prefix} (offset 0x{offset}) {text}*/
 std::string AddOffset(const std::string& prefix, const std::string& text, unsigned int offset);
 
@@ -84,7 +84,7 @@ std::string AddOffset(const std::string& prefix, const std::string& text, unsign
  *  @param prefix Message prefix to be preprended to the location info.
  *  @param text Message text
  *  @param line Line index, 1-based
- *  @param column Colum index, 1-based
+ *  @param column Column index, 1-based
  *  @return A string of the following format: {prefix} (line {line}, col {column}) {text}*/
 std::string AddLineAndColumn(const std::string& prefix, const std::string& text, unsigned int line, unsigned int column);
 

code/FileSystemFilter.h

@@ -40,7 +40,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 /** @file FileSystemFilter.h
  *  Implements a filter system to filter calls to Exists() and Open()
- *  in order to improve the sucess rate of file opening ...
+ *  in order to improve the success rate of file opening ...
  */
 #ifndef AI_FILESYSTEMFILTER_H_INC
 #define AI_FILESYSTEMFILTER_H_INC

code/FindInstancesProcess.cpp

@@ -45,7 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include "FindInstancesProcess.h"
-#include <boost/scoped_array.hpp>
+#include <memory>
 #include <stdio.h>
 
 using namespace Assimp;
@@ -126,8 +126,8 @@ void FindInstancesProcess::Execute( aiScene* pScene)
         // have several thousand small meshes. That's too much for a brute
         // everyone-against-everyone check involving up to 10 comparisons
         // each.
-        boost::scoped_array<uint64_t> hashes (new uint64_t[pScene->mNumMeshes]);
-        boost::scoped_array<unsigned int> remapping (new unsigned int[pScene->mNumMeshes]);
+        std::unique_ptr<uint64_t[]> hashes (new uint64_t[pScene->mNumMeshes]);
+        std::unique_ptr<unsigned int[]> remapping (new unsigned int[pScene->mNumMeshes]);
 
         unsigned int numMeshesOut = 0;
         for (unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
@@ -219,8 +219,8 @@ void FindInstancesProcess::Execute( aiScene* pScene)
 
                         // For completeness ... compare even the index buffers for equality
                         // face order & winding order doesn't care. Input data is in verbose format.
-                        boost::scoped_array<unsigned int> ftbl_orig(new unsigned int[orig->mNumVertices]);
-                        boost::scoped_array<unsigned int> ftbl_inst(new unsigned int[orig->mNumVertices]);
+                        std::unique_ptr<unsigned int[]> ftbl_orig(new unsigned int[orig->mNumVertices]);
+                        std::unique_ptr<unsigned int[]> ftbl_inst(new unsigned int[orig->mNumVertices]);
 
                         for (unsigned int tt = 0; tt < orig->mNumFaces;++tt) {
                             aiFace& f = orig->mFaces[tt];

code/HMPLoader.cpp

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "HMPLoader.h"
 #include "MD2FileData.h"
-#include <boost/scoped_ptr.hpp>
+#include <memory>
 #include "../include/assimp/IOSystem.hpp"
 #include "../include/assimp/DefaultLogger.hpp"
 #include "../include/assimp/scene.h"
@@ -114,7 +114,7 @@ void HMPImporter::InternReadFile( const std::string& pFile,
 {
     pScene     = _pScene;
     pIOHandler = _pIOHandler;
-    boost::scoped_ptr<IOStream> file( pIOHandler->Open( pFile));
+    std::unique_ptr<IOStream> file( pIOHandler->Open( pFile));
 
     // Check whether we can read from the file
     if( file.get() == NULL)

code/IFCBoolean.cpp

@@ -50,7 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "Defines.h"
 
 #include <iterator>
-#include <boost/tuple/tuple.hpp>
+#include <tuple>
 
 
 namespace Assimp {
@@ -413,7 +413,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
     n.Normalize();
 
     // obtain the polygonal bounding volume
-    boost::shared_ptr<TempMesh> profile = boost::shared_ptr<TempMesh>(new TempMesh());
+    std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
     if(!ProcessCurve(hs->PolygonalBoundary, *profile.get(), conv)) {
         IFCImporter::LogError("expected valid polyline for boundary of boolean halfspace");
         return;
@@ -510,7 +510,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
         if( !blackside.empty() )
         {
             // poly edge index, intersection point, edge index in boundary poly
-            std::vector<boost::tuple<size_t, IfcVector3, size_t> > intersections;
+            std::vector<std::tuple<size_t, IfcVector3, size_t> > intersections;
             bool startedInside = PointInPoly(proj * blackside.front(), profile->verts);
             bool isCurrentlyInside = startedInside;
 
@@ -542,7 +542,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                 }
                 // now add them to the list of intersections
                 for( size_t b = 0; b < intersected_boundary.size(); ++b )
-                    intersections.push_back(boost::make_tuple(a, proj_inv * intersected_boundary[b].second, intersected_boundary[b].first));
+                    intersections.push_back(std::make_tuple(a, proj_inv * intersected_boundary[b].second, intersected_boundary[b].first));
 
                 // and calculate our new inside/outside state
                 if( intersected_boundary.size() & 1 )
@@ -568,12 +568,12 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                 // Filter pairs of out->in->out that lie too close to each other.
                 for( size_t a = 0; intersections.size() > 0 && a < intersections.size() - 1; /**/ )
                 {
-                    if( (intersections[a].get<1>() - intersections[(a + 1) % intersections.size()].get<1>()).SquareLength() < 1e-10 )
+                    if( (std::get<1>(intersections[a]) - std::get<1>(intersections[(a + 1) % intersections.size()])).SquareLength() < 1e-10 )
                         intersections.erase(intersections.begin() + a, intersections.begin() + a + 2);
                     else
                         a++;
                 }
-                if( intersections.size() > 1 && (intersections.back().get<1>() - intersections.front().get<1>()).SquareLength() < 1e-10 )
+                if( intersections.size() > 1 && (std::get<1>(intersections.back()) - std::get<1>(intersections.front())).SquareLength() < 1e-10 )
                 {
                     intersections.pop_back(); intersections.erase(intersections.begin());
                 }
@@ -619,23 +619,23 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                 while( true )
                 {
                     ai_assert(intersections.size() > currentIntersecIdx + 1);
-                    boost::tuple<size_t, IfcVector3, size_t> currintsec = intersections[currentIntersecIdx + 0];
-                    boost::tuple<size_t, IfcVector3, size_t> nextintsec = intersections[currentIntersecIdx + 1];
+                    std::tuple<size_t, IfcVector3, size_t> currintsec = intersections[currentIntersecIdx + 0];
+                    std::tuple<size_t, IfcVector3, size_t> nextintsec = intersections[currentIntersecIdx + 1];
                     intersections.erase(intersections.begin() + currentIntersecIdx, intersections.begin() + currentIntersecIdx + 2);
 
                     // we start with an in->out intersection
-                    resultpoly.push_back(currintsec.get<1>());
+                    resultpoly.push_back(std::get<1>(currintsec));
                     // climb along the polygon to the next intersection, which should be an out->in
-                    size_t numPolyPoints = (currintsec.get<0>() > nextintsec.get<0>() ? blackside.size() : 0)
-                        + nextintsec.get<0>() - currintsec.get<0>();
+                    size_t numPolyPoints = (std::get<0>(currintsec) > std::get<0>(nextintsec) ? blackside.size() : 0)
+                        + std::get<0>(nextintsec) - std::get<0>(currintsec);
                     for( size_t a = 1; a <= numPolyPoints; ++a )
-                        resultpoly.push_back(blackside[(currintsec.get<0>() + a) % blackside.size()]);
+                        resultpoly.push_back(blackside[(std::get<0>(currintsec) + a) % blackside.size()]);
                     // put the out->in intersection
-                    resultpoly.push_back(nextintsec.get<1>());
+                    resultpoly.push_back(std::get<1>(nextintsec));
 
                     // generate segments along the boundary polygon that lie in the poly's plane until we hit another intersection
-                    IfcVector3 startingPoint = proj * nextintsec.get<1>();
-                    size_t currentBoundaryEdgeIdx = (nextintsec.get<2>() + (marchBackwardsOnBoundary ? 1 : 0)) % profile->verts.size();
+                    IfcVector3 startingPoint = proj * std::get<1>(nextintsec);
+                    size_t currentBoundaryEdgeIdx = (std::get<2>(nextintsec) + (marchBackwardsOnBoundary ? 1 : 0)) % profile->verts.size();
                     size_t nextIntsecIdx = SIZE_MAX;
                     while( nextIntsecIdx == SIZE_MAX )
                     {
@@ -676,7 +676,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                         // to marching along the poly border from that intersection point
                         for( size_t a = 0; a < intersections.size(); a += 2 )
                         {
-                            dirToThatPoint = proj * intersections[a].get<1>() - startingPoint;
+                            dirToThatPoint = proj * std::get<1>(intersections[a]) - startingPoint;
                             tpt = dirToThatPoint * dirAtPolyPlane;
                             if( tpt > -1e-6 && tpt <= t && (dirToThatPoint - tpt * dirAtPolyPlane).SquareLength() < 1e-10 )
                             {
@@ -730,17 +730,17 @@ void ProcessBooleanExtrudedAreaSolidDifference(const IfcExtrudedAreaSolid* as, T
     // operand should be near-planar. Luckily, this is usually the case in Ifc
     // buildings.
 
-    boost::shared_ptr<TempMesh> meshtmp = boost::shared_ptr<TempMesh>(new TempMesh());
+    std::shared_ptr<TempMesh> meshtmp = std::shared_ptr<TempMesh>(new TempMesh());
     ProcessExtrudedAreaSolid(*as,*meshtmp,conv,false);
 
-    std::vector<TempOpening> openings(1, TempOpening(as,IfcVector3(0,0,0),meshtmp,boost::shared_ptr<TempMesh>()));
+    std::vector<TempOpening> openings(1, TempOpening(as,IfcVector3(0,0,0),meshtmp,std::shared_ptr<TempMesh>()));
 
     result = first_operand;
 
     TempMesh temp;
 
     std::vector<IfcVector3>::const_iterator vit = first_operand.verts.begin();
-    BOOST_FOREACH(unsigned int pcount, first_operand.vertcnt) {
+    for(unsigned int pcount : first_operand.vertcnt) {
         temp.Clear();
 
         temp.verts.insert(temp.verts.end(), vit, vit + pcount);

code/IFCCurve.cpp

@@ -229,7 +229,7 @@ private:
 class CompositeCurve : public BoundedCurve
 {
 
-    typedef std::pair< boost::shared_ptr< BoundedCurve >, bool > CurveEntry;
+    typedef std::pair< std::shared_ptr< BoundedCurve >, bool > CurveEntry;
 
 public:
 
@@ -239,10 +239,10 @@ public:
         , total()
     {
         curves.reserve(entity.Segments.size());
-        BOOST_FOREACH(const IfcCompositeCurveSegment& curveSegment,entity.Segments) {
+        for(const IfcCompositeCurveSegment& curveSegment :entity.Segments) {
             // according to the specification, this must be a bounded curve
-            boost::shared_ptr< Curve > cv(Curve::Convert(curveSegment.ParentCurve,conv));
-            boost::shared_ptr< BoundedCurve > bc = boost::dynamic_pointer_cast<BoundedCurve>(cv);
+            std::shared_ptr< Curve > cv(Curve::Convert(curveSegment.ParentCurve,conv));
+            std::shared_ptr< BoundedCurve > bc = std::dynamic_pointer_cast<BoundedCurve>(cv);
 
             if (!bc) {
                 IFCImporter::LogError("expected segment of composite curve to be a bounded curve");
@@ -271,7 +271,7 @@ public:
         }
 
         IfcFloat acc = 0;
-        BOOST_FOREACH(const CurveEntry& entry, curves) {
+        for(const CurveEntry& entry : curves) {
             const ParamRange& range = entry.first->GetParametricRange();
             const IfcFloat delta = std::abs(range.second-range.first);
             if (u < acc+delta) {
@@ -290,7 +290,7 @@ public:
         size_t cnt = 0;
 
         IfcFloat acc = 0;
-        BOOST_FOREACH(const CurveEntry& entry, curves) {
+        for(const CurveEntry& entry : curves) {
             const ParamRange& range = entry.first->GetParametricRange();
             const IfcFloat delta = std::abs(range.second-range.first);
             if (a <= acc+delta && b >= acc) {
@@ -312,7 +312,7 @@ public:
         const size_t cnt = EstimateSampleCount(a,b);
         out.verts.reserve(out.verts.size() + cnt);
 
-        BOOST_FOREACH(const CurveEntry& entry, curves) {
+        for(const CurveEntry& entry : curves) {
             const size_t cnt = out.verts.size();
             entry.first->SampleDiscrete(out);
 
@@ -346,9 +346,9 @@ public:
     TrimmedCurve(const IfcTrimmedCurve& entity, ConversionData& conv)
         : BoundedCurve(entity,conv)
     {
-        base = boost::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv));
+        base = std::shared_ptr<const Curve>(Curve::Convert(entity.BasisCurve,conv));
 
-        typedef boost::shared_ptr<const STEP::EXPRESS::DataType> Entry;
+        typedef std::shared_ptr<const STEP::EXPRESS::DataType> Entry;
 
         // for some reason, trimmed curves can either specify a parametric value
         // or a point on the curve, or both. And they can even specify which of the
@@ -357,7 +357,7 @@ public:
         // oh well.
         bool have_param = false, have_point = false;
         IfcVector3 point;
-        BOOST_FOREACH(const Entry sel,entity.Trim1) {
+        for(const Entry sel :entity.Trim1) {
             if (const EXPRESS::REAL* const r = sel->ToPtr<EXPRESS::REAL>()) {
                 range.first = *r;
                 have_param = true;
@@ -374,7 +374,7 @@ public:
             }
         }
         have_param = false, have_point = false;
-        BOOST_FOREACH(const Entry sel,entity.Trim2) {
+        for(const Entry sel :entity.Trim2) {
             if (const EXPRESS::REAL* const r = sel->ToPtr<EXPRESS::REAL>()) {
                 range.second = *r;
                 have_param = true;
@@ -446,7 +446,7 @@ private:
     IfcFloat maxval;
     bool agree_sense;
 
-    boost::shared_ptr<const Curve> base;
+    std::shared_ptr<const Curve> base;
 };
 
 
@@ -465,7 +465,7 @@ public:
         points.reserve(entity.Points.size());
 
         IfcVector3 t;
-        BOOST_FOREACH(const IfcCartesianPoint& cp, entity.Points) {
+        for(const IfcCartesianPoint& cp : entity.Points) {
             ConvertCartesianPoint(t,cp);
             points.push_back(t);
         }

code/IFCGeometry.cpp

@@ -51,7 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "../contrib/poly2tri/poly2tri/poly2tri.h"
 #include "../contrib/clipper/clipper.hpp"
-#include <boost/make_shared.hpp>
+#include <memory>
 
 #include <iterator>
 
@@ -62,7 +62,7 @@ namespace Assimp {
 bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData& /*conv*/)
 {
     size_t cnt = 0;
-    BOOST_FOREACH(const IfcCartesianPoint& c, loop.Polygon) {
+    for(const IfcCartesianPoint& c : loop.Polygon) {
         IfcVector3 tmp;
         ConvertCartesianPoint(tmp,c);
 
@@ -170,7 +170,7 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
         opening.extrusionDir = master_normal;
         opening.solid = NULL;
 
-        opening.profileMesh = boost::make_shared<TempMesh>();
+        opening.profileMesh = std::make_shared<TempMesh>();
         opening.profileMesh->verts.reserve(*iit);
         opening.profileMesh->vertcnt.push_back(*iit);
 
@@ -191,10 +191,10 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
 // ------------------------------------------------------------------------------------------------
 void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result, ConversionData& conv)
 {
-    BOOST_FOREACH(const IfcFace& face, fset.CfsFaces) {
+    for(const IfcFace& face : fset.CfsFaces) {
         // size_t ob = -1, cnt = 0;
         TempMesh meshout;
-        BOOST_FOREACH(const IfcFaceBound& bound, face.Bounds) {
+        for(const IfcFaceBound& bound : face.Bounds) {
 
             if(const IfcPolyLoop* const polyloop = bound.Bound->ToPtr<IfcPolyLoop>()) {
                 if(ProcessPolyloop(*polyloop, meshout,conv)) {
@@ -219,7 +219,7 @@ void ProcessConnectedFaceSet(const IfcConnectedFaceSet& fset, TempMesh& result,
 
             /*if(!IsTrue(bound.Orientation)) {
                 size_t c = 0;
-                BOOST_FOREACH(unsigned int& c, meshout.vertcnt) {
+                for(unsigned int& c : meshout.vertcnt) {
                     std::reverse(result.verts.begin() + cnt,result.verts.begin() + cnt + c);
                     cnt += c;
                 }
@@ -547,7 +547,7 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
 
     IfcVector3 vmin, vmax;
     MinMaxChooser<IfcVector3>()(vmin, vmax);
-    BOOST_FOREACH(IfcVector3& v, in) {
+    for(IfcVector3& v : in) {
         v *= trafo;
 
         vmin = std::min(vmin, v);
@@ -579,7 +579,7 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
         }
 
         nors.reserve(conv.apply_openings->size());
-        BOOST_FOREACH(TempOpening& t, *conv.apply_openings) {
+        for(TempOpening& t : *conv.apply_openings) {
             TempMesh& bounds = *t.profileMesh.get();
 
             if( bounds.verts.size() <= 2 ) {
@@ -617,7 +617,7 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
     }
 
     if( openings ) {
-        BOOST_FOREACH(TempOpening& opening, *conv.apply_openings) {
+        for(TempOpening& opening : *conv.apply_openings) {
             if( !opening.wallPoints.empty() ) {
                 IFCImporter::LogError("failed to generate all window caps");
             }
@@ -660,10 +660,10 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
     // it was created from. Return an empty mesh to the caller.
     if( collect_openings && !result.IsEmpty() ) {
         ai_assert(conv.collect_openings);
-        boost::shared_ptr<TempMesh> profile = boost::shared_ptr<TempMesh>(new TempMesh());
+        std::shared_ptr<TempMesh> profile = std::shared_ptr<TempMesh>(new TempMesh());
         profile->Swap(result);
 
-        boost::shared_ptr<TempMesh> profile2D = boost::shared_ptr<TempMesh>(new TempMesh());
+        std::shared_ptr<TempMesh> profile2D = std::shared_ptr<TempMesh>(new TempMesh());
         profile2D->verts.insert(profile2D->verts.end(), in.begin(), in.end());
         profile2D->vertcnt.push_back(in.size());
         conv.collect_openings->push_back(TempOpening(&solid, dir, profile, profile2D));
@@ -697,7 +697,7 @@ void ProcessExtrudedAreaSolid(const IfcExtrudedAreaSolid& solid, TempMesh& resul
             std::vector<TempOpening>* oldCollectOpenings = conv.collect_openings;
             conv.collect_openings = &fisherPriceMyFirstOpenings;
 
-            BOOST_FOREACH(const IfcCurve* curve, cprofile->InnerCurves) {
+            for(const IfcCurve* curve : cprofile->InnerCurves) {
                 TempMesh curveMesh, tempMesh;
                 ProcessCurve(*curve, curveMesh, conv);
                 ProcessExtrudedArea(solid, curveMesh, dir, tempMesh, conv, true);
@@ -732,9 +732,9 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid,
     ConversionData& conv)
 {
     bool fix_orientation = false;
-    boost::shared_ptr< TempMesh > meshtmp = boost::make_shared<TempMesh>();
+    std::shared_ptr< TempMesh > meshtmp = std::make_shared<TempMesh>();
     if(const IfcShellBasedSurfaceModel* shellmod = geo.ToPtr<IfcShellBasedSurfaceModel>()) {
-        BOOST_FOREACH(boost::shared_ptr<const IfcShell> shell,shellmod->SbsmBoundary) {
+        for(std::shared_ptr<const IfcShell> shell :shellmod->SbsmBoundary) {
             try {
                 const EXPRESS::ENTITY& e = shell->To<ENTITY>();
                 const IfcConnectedFaceSet& fs = conv.db.MustGetObject(e).To<IfcConnectedFaceSet>();
@@ -762,7 +762,7 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid,
         fix_orientation = true;
     }
     else if(const IfcFaceBasedSurfaceModel* surf = geo.ToPtr<IfcFaceBasedSurfaceModel>()) {
-        BOOST_FOREACH(const IfcConnectedFaceSet& fc, surf->FbsmFaces) {
+        for(const IfcConnectedFaceSet& fc : surf->FbsmFaces) {
             ProcessConnectedFaceSet(fc,*meshtmp.get(),conv);
         }
         fix_orientation = true;
@@ -791,7 +791,7 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid,
             conv.collect_openings->push_back(TempOpening(geo.ToPtr<IfcSolidModel>(),
                 IfcVector3(0,0,0),
                 meshtmp,
-                boost::shared_ptr<TempMesh>()));
+                std::shared_ptr<TempMesh>()));
         }
         return true;
     }

code/IFCLoader.cpp

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <iterator>
 #include <limits>
-#include <boost/tuple/tuple.hpp>
+#include <tuple>
 
 #ifndef ASSIMP_BUILD_NO_COMPRESSED_IFC
 #   include "../contrib/unzip/unzip.h"
@@ -168,7 +168,7 @@ void IFCImporter::SetupProperties(const Importer* pImp)
 void IFCImporter::InternReadFile( const std::string& pFile,
     aiScene* pScene, IOSystem* pIOHandler)
 {
-    boost::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
+    std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile));
     if (!stream) {
         ThrowException("Could not open file for reading");
     }
@@ -233,7 +233,7 @@ void IFCImporter::InternReadFile( const std::string& pFile,
 #endif
     }
 
-    boost::scoped_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
+    std::unique_ptr<STEP::DB> db(STEP::ReadFileHeader(stream));
     const STEP::HeaderInfo& head = static_cast<const STEP::DB&>(*db).GetHeader();
 
     if(!head.fileSchema.size() || head.fileSchema.substr(0,3) != "IFC") {
@@ -383,7 +383,7 @@ void SetUnits(ConversionData& conv)
 void SetCoordinateSpace(ConversionData& conv)
 {
     const IfcRepresentationContext* fav = NULL;
-    BOOST_FOREACH(const IfcRepresentationContext& v, conv.proj.RepresentationContexts) {
+    for(const IfcRepresentationContext& v : conv.proj.RepresentationContexts) {
         fav = &v;
         // Model should be the most suitable type of context, hence ignore the others
         if (v.ContextType && v.ContextType.Get() == "Model") {
@@ -423,7 +423,7 @@ void ResolveObjectPlacement(aiMatrix4x4& m, const IfcObjectPlacement& place, Con
 bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector< aiNode* >& subnodes_src, unsigned int matid, ConversionData& conv)
 {
     // insert a custom node here, the cartesian transform operator is simply a conventional transformation matrix
-    std::auto_ptr<aiNode> nd(new aiNode());
+    std::unique_ptr<aiNode> nd(new aiNode());
     nd->mName.Set("IfcMappedItem");
 
     // handle the Cartesian operator
@@ -440,7 +440,7 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector<
     if (conv.apply_openings) {
         IfcMatrix4 minv = msrc;
         minv.Inverse();
-        BOOST_FOREACH(TempOpening& open,*conv.apply_openings){
+        for(TempOpening& open :*conv.apply_openings){
             open.Transform(minv);
         }
     }
@@ -449,7 +449,7 @@ bool ProcessMappedItem(const IfcMappedItem& mapped, aiNode* nd_src, std::vector<
     const IfcRepresentation& repr = mapped.MappingSource->MappedRepresentation;
 
     bool got = false;
-    BOOST_FOREACH(const IfcRepresentationItem& item, repr.Items) {
+    for(const IfcRepresentationItem& item : repr.Items) {
         if(!ProcessRepresentationItem(item,localmatid,meshes,conv)) {
             IFCImporter::LogWarn("skipping mapped entity of type " + item.GetClassName() + ", no representations could be generated");
         }
@@ -564,9 +564,9 @@ void ProcessProductRepresentation(const IfcProduct& el, aiNode* nd, std::vector<
     std::vector<const IfcRepresentation*> repr_ordered(src.size());
     std::copy(src.begin(),src.end(),repr_ordered.begin());
     std::sort(repr_ordered.begin(),repr_ordered.end(),RateRepresentationPredicate());
-    BOOST_FOREACH(const IfcRepresentation* repr, repr_ordered) {
+    for(const IfcRepresentation* repr : repr_ordered) {
         bool res = false;
-        BOOST_FOREACH(const IfcRepresentationItem& item, repr->Items) {
+        for(const IfcRepresentationItem& item : repr->Items) {
             if(const IfcMappedItem* const geo = item.ToPtr<IfcMappedItem>()) {
                 res = ProcessMappedItem(*geo,nd,subnodes,matid,conv) || res;
             }
@@ -589,7 +589,7 @@ void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionD
     const std::string& prefix = "",
     unsigned int nest = 0)
 {
-    BOOST_FOREACH(const IfcProperty& property, set) {
+    for(const IfcProperty& property : set) {
         const std::string& key = prefix.length() > 0 ? (prefix + "." + property.Name) : property.Name;
         if (const IfcPropertySingleValue* const singleValue = property.ToPtr<IfcPropertySingleValue>()) {
             if (singleValue->NominalValue) {
@@ -615,7 +615,7 @@ void ProcessMetadata(const ListOf< Lazy< IfcProperty >, 1, 0 >& set, ConversionD
             std::stringstream ss;
             ss << "[";
             unsigned index=0;
-            BOOST_FOREACH(const IfcValue::Out& v, listValue->ListValues) {
+            for(const IfcValue::Out& v : listValue->ListValues) {
                 if (!v) continue;
                 if (const EXPRESS::STRING* str = v->ToPtr<EXPRESS::STRING>()) {
                     std::string value = static_cast<std::string>(*str);
@@ -684,7 +684,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
     }
 
     // add an output node for this spatial structure
-    std::auto_ptr<aiNode> nd(new aiNode());
+    std::unique_ptr<aiNode> nd(new aiNode());
     nd->mName.Set(el.GetClassName()+"_"+(el.Name?el.Name.Get():"Unnamed")+"_"+el.GlobalId);
     nd->mParent = parent;
 
@@ -713,7 +713,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
             data->mValues = new aiMetadataEntry[data->mNumProperties]();
 
             unsigned int index = 0;
-            BOOST_FOREACH(const Metadata::value_type& kv, properties)
+            for(const Metadata::value_type& kv : properties)
                 data->Set(index++, kv.first, aiString(kv.second));
 
             nd->mMetaData = data;
@@ -751,7 +751,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
                 if(cont->RelatingStructure->GetID() != el.GetID()) {
                     continue;
                 }
-                BOOST_FOREACH(const IfcProduct& pro, cont->RelatedElements) {
+                for(const IfcProduct& pro : cont->RelatedElements) {
                     if(pro.ToPtr<IfcOpeningElement>()) {
                         // IfcOpeningElement is handled below. Sadly we can't use it here as is:
                         // The docs say that opening elements are USUALLY attached to building storey,
@@ -771,7 +771,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
                     const IfcFeatureElementSubtraction& open = fills->RelatedOpeningElement;
 
                     // move opening elements to a separate node since they are semantically different than elements that are just 'contained'
-                    std::auto_ptr<aiNode> nd_aggr(new aiNode());
+                    std::unique_ptr<aiNode> nd_aggr(new aiNode());
                     nd_aggr->mName.Set("$RelVoidsElement");
                     nd_aggr->mParent = nd.get();
 
@@ -794,7 +794,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
                             }
 
                             // we need all openings to be in the local space of *this* node, so transform them
-                            BOOST_FOREACH(TempOpening& op,openings_local) {
+                            for(TempOpening& op :openings_local) {
                                 op.Transform( myInv*nd_aggr->mChildren[0]->mTransformation);
                                 openings.push_back(op);
                             }
@@ -816,14 +816,14 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
                 }
 
                 // move aggregate elements to a separate node since they are semantically different than elements that are just 'contained'
-                std::auto_ptr<aiNode> nd_aggr(new aiNode());
+                std::unique_ptr<aiNode> nd_aggr(new aiNode());
                 nd_aggr->mName.Set("$RelAggregates");
                 nd_aggr->mParent = nd.get();
 
                 nd_aggr->mTransformation = nd->mTransformation;
 
                 nd_aggr->mChildren = new aiNode*[aggr->RelatedObjects.size()]();
-                BOOST_FOREACH(const IfcObjectDefinition& def, aggr->RelatedObjects) {
+                for(const IfcObjectDefinition& def : aggr->RelatedObjects) {
                     if(const IfcProduct* const prod = def.ToPtr<IfcProduct>()) {
 
                         aiNode* const ndnew = ProcessSpatialStructure(nd_aggr.get(),*prod,conv,NULL);
@@ -849,7 +849,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
 
         if (subnodes.size()) {
             nd->mChildren = new aiNode*[subnodes.size()]();
-            BOOST_FOREACH(aiNode* nd2, subnodes) {
+            for(aiNode* nd2 : subnodes) {
                 nd->mChildren[nd->mNumChildren++] = nd2;
                 nd2->mParent = nd.get();
             }
@@ -889,7 +889,7 @@ void ProcessSpatialStructures(ConversionData& conv)
     }
 
 
-    BOOST_FOREACH(const STEP::LazyObject* lz, *range) {
+    for(const STEP::LazyObject* lz : *range) {
         const IfcSpatialStructureElement* const prod = lz->ToPtr<IfcSpatialStructureElement>();
         if(!prod) {
             continue;
@@ -902,7 +902,7 @@ void ProcessSpatialStructures(ConversionData& conv)
         for(;range.first != range.second; ++range.first) {
             if(const IfcRelAggregates* const aggr = conv.db.GetObject((*range.first).second)->ToPtr<IfcRelAggregates>()) {
 
-                BOOST_FOREACH(const IfcObjectDefinition& def, aggr->RelatedObjects) {
+                for(const IfcObjectDefinition& def : aggr->RelatedObjects) {
                     // comparing pointer values is not sufficient, we would need to cast them to the same type first
                     // as there is multiple inheritance in the game.
                     if (def.GetID() == prod->GetID()) {
@@ -919,7 +919,7 @@ void ProcessSpatialStructures(ConversionData& conv)
 
 
     IFCImporter::LogWarn("failed to determine primary site element, taking the first IfcSite");
-    BOOST_FOREACH(const STEP::LazyObject* lz, *range) {
+    for(const STEP::LazyObject* lz : *range) {
         const IfcSpatialStructureElement* const prod = lz->ToPtr<IfcSpatialStructureElement>();
         if(!prod) {
             continue;

code/IFCMaterial.cpp

@@ -76,7 +76,7 @@ void FillMaterial(aiMaterial* mat,const IFC::IfcSurfaceStyle* surf,ConversionDat
     mat->AddProperty(&name,AI_MATKEY_NAME);
 
     // now see which kinds of surface information are present
-    BOOST_FOREACH(boost::shared_ptr< const IFC::IfcSurfaceStyleElementSelect > sel2, surf->Styles) {
+    for(std::shared_ptr< const IFC::IfcSurfaceStyleElementSelect > sel2 : surf->Styles) {
         if (const IFC::IfcSurfaceStyleShading* shade = sel2->ResolveSelectPtr<IFC::IfcSurfaceStyleShading>(conv.db)) {
             aiColor4D col_base,col;
 
@@ -139,8 +139,8 @@ unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionDat
     STEP::DB::RefMapRange range = conv.db.GetRefs().equal_range(id);
     for(;range.first != range.second; ++range.first) {
         if(const IFC::IfcStyledItem* const styled = conv.db.GetObject((*range.first).second)->ToPtr<IFC::IfcStyledItem>()) {
-            BOOST_FOREACH(const IFC::IfcPresentationStyleAssignment& as, styled->Styles) {
-                BOOST_FOREACH(boost::shared_ptr<const IFC::IfcPresentationStyleSelect> sel, as.Styles) {
+            for(const IFC::IfcPresentationStyleAssignment& as : styled->Styles) {
+                for(std::shared_ptr<const IFC::IfcPresentationStyleSelect> sel : as.Styles) {
 
                     if( const IFC::IfcSurfaceStyle* const surf = sel->ResolveSelectPtr<IFC::IfcSurfaceStyle>(conv.db) ) {
                         // try to satisfy from cache
@@ -154,7 +154,7 @@ unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionDat
                             IFCImporter::LogWarn("ignoring surface side marker on IFC::IfcSurfaceStyle: " + side);
                         }
 
-                        std::auto_ptr<aiMaterial> mat(new aiMaterial());
+                        std::unique_ptr<aiMaterial> mat(new aiMaterial());
 
                         FillMaterial(mat.get(), surf, conv);
 
@@ -190,7 +190,7 @@ unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionDat
     }
 
     // we're here, yet - no default material with suitable color available. Generate one
-    std::auto_ptr<aiMaterial> mat(new aiMaterial());
+    std::unique_ptr<aiMaterial> mat(new aiMaterial());
     mat->AddProperty(&name,AI_MATKEY_NAME);
 
     const aiColor4D col = aiColor4D( 0.6f, 0.6f, 0.6f, 1.0f); // aiColor4D( color.r, color.g, color.b, 1.0f);