Merge branch 'master' into coverity_scan

.gitattributes

@@ -2,7 +2,14 @@
 *.cpp text eol=lf
 *.h text eol=lf
 *.c text eol=lf
+*.cc text eol=lf
+*.cpp text eol=lf
+*.rc text eol=lf
 *.hpp text eol=lf
 *.txt text eol=lf
 *.cmake text eol=lf
 *.sh text eol=lf
+CHANGES text eol=lf
+CREDITS text eol=lf
+LICENSE text eol=lf
+Readme.md text eol=lf

CHANGES

@@ -1,173 +1,205 @@
-----------------------------------------------------------------------
-CHANGELOG
-----------------------------------------------------------------------
-
-3.2.1 (2016-10-01)
-
-FEATURES:
-  - Updated glTF exporter to meet 1.0 specification.
-
-FIXES/HOUSEKEEPING:
-  - Fixed glTF Validator errors for exported glTF format.
-
-ISSUES:
-  - Hard coded sampler setting for
-    - magFilter
-    - minFilter
-  - void* in ExportData for accessor max and min.
-
-
-
-3.2.0 (2015-11-03)
-
-FEATURES:
-  - OpenDDL-Parser is part of contrib-source.
-  - Experimental OpenGEX-support
-  - CI-check for linux and windows
-  - Coverity check added
-  - New regression testsuite.
-
-FIXES/HOUSEKEEPING:
-  - Hundreds of bugfixes  in all parts of the library
-  - Unified line endings
-
-
-API COMPATIBILITY:
-  - Removed precompiled header to increase build speed for linux
-
-
-3.1.1 (2014-06-15)
-
-FEATURES:
-   - Support for FBX 2013 and newer, binary and ASCII (this is partly
-     work from Google Summer of Code 2012)
-   - Support for OGRE binary mesh and skeleton format
-   - Updated BLEND support for newer Blender versions
-   - Support for arbitrary meta data, used to hold FBX and DAE metadata
-   - OBJ Export now produces smaller files
-   - Meshes can now have names, this is supported by the major importers
-   - Improved IFC geometry generation
-   - M3 support has been removed
-
-FIXES/HOUSEKEEPING:
-    - Hundreds of bugfixes in all parts of the library
-    - CMake is now the primary build system
-
-API COMPATIBILITY:
-    - 3.1.1 is not binary compatible to 3.0 due to aiNode::mMetaData
-      and aiMesh::mName
-    - Export interface has been cleaned up and unified
-    - Other than that no relevant changes
-
-
-3.0 (2012-07-07)
-
-FEATURES:
-   - new export interface similar to the import API.
-   - Supported export formats: Collada, OBJ, PLY and STL
-   - added new import formats: XGL/ZGL, M3 (experimental)
-   - new postprocessing steps: Debone
-   - vastly improved IFC (Industry Foundation Classes) support
-   - introduced API to query importer meta information (such as supported
-       format versions, full name, maintainer info).
-   - reworked Ogre XML import
-   - C-API now supports per-import properties
-
-FIXES/HOUSEKEEPING:
-
-   - hundreds of bugfixes in all parts of the library
-   - unified naming and cleanup of public headers
-   - improved CMake build system
-   - templatized math library
-   - reduce dependency on boost.thread, only remaining spot
-     is synchronization for the C logging API
-
-API COMPATIBILITY:
-   - renamed headers, export interface, C API properties and meta data
-     prevent compatibility with code written for 2.0, but in
-     most cases these can be easily resolved
-   - Note: 3.0 is not binary compatible with 2.0
-
-
-
-
-2.0 (2010-11-21)
-
-FEATURES:
-   - Add support for static Blender (*.blend) scenes
-   - Add support for Q3BSP scenes
-   - Add a windows-based OpenGL sample featuring texturing & basic materials
-   - Add an experimental progress feedback interface.
-   - Vastly improved performance (up to 500%, depending on mesh size and
-     spatial structure) in some expensive postprocessing steps
-   - AssimpView now uses a reworked layout which leaves more space
-     to the scene hierarchy window
-
-   - Add C# bindings ('Assimp.NET')
-   - Keep BSD-licensed and otherwise free test files in separate
-     folders (./test/models and ./test/models-nonbsd).
-
-FIXES:
-   - Many Collada bugfixes, improve fault tolerance
-   - Fix possible crashes in the Obj loader
-   - Improve the Ogre XML loader
-   - OpenGL-sample now works with MinGW
-   - Fix Importer::FindLoader failing on uppercase file extensions
-   - Fix flawed path handling when locating external files
-   - Limit the maximum number of vertices, faces, face indices and
-     weights that Assimp is able to handle. This is to avoid
-     crashes due to overflowing counters.
-
-   - Updated XCode project files
-   - Further CMAKE build improvements
-
-
-API CHANGES:
-   - Add data structures for vertex-based animations (These are not
-     currently used, however ...)
-   - Some Assimp::Importer methods are const now.
-
-
-
-
-
-1.1 (2010-04-17)
-This is the list of relevant changes from the 1.0 (r412) release to 1.1 (r700).
-
-FEATURES:
-  - Vastly improved Collada support
-  - Add MS3D (Milkshape 3D) support
-  - Add support for Ogre XML static meshes
-  - Add experimental COB (TrueSpace) support
-  - Automatic test suite to quickly locate regressions
-  - D bindings (`dAssimp`)
-  - Python 2.n bindings (`PyAssimp`)
-  - Add basic support for Unicode input files (utf8, utf16 and utf32)
-  - Add further utilities to the `assimp` tool (xml/binary dumps, quick file stats)
-  - Switch to a CMAKE-based build system including an install target for unix'es
-  - Automatic evaluation of subdivision surfaces for some formats.
-  - Add `Importer::ReadFileFromMemory` and the corresponding C-API `aiReadFileFromMemory`
-  - Expose further math utilities via the C-API (i.e. `aiMultiplyMatrix4`)
-
-  - Move noboost files away from the public include directory
-  - Many, many bugfixes and improvements in existing loaders and postprocessing steps
-  - Documentation improved and clarified in many places.
-  - Add a sample on using Assimp in conjunction with OpenGL
-
-  - Distribution/packaging: comfortable SDK installer for Windows
-  - Distribution/packaging: improved release packages for other architectures
-
-CRITICAL FIXES:
-  - Resolve problems with clashing heap managers, STL ABIs and runtime libraries (win32)
-  - Fix automatic detection of file type if no file extension is given
-  - Improved exception safety and robustness, prevent leaking of exceptions through the C interface
-  - Fix possible heap corruption due to material properties pulled in incorrectly
-  - Avoid leaking in certain error scenarios
-  - Fix 64 bit compatibility problems in some loaders (i.e. MDL)
-
-BREAKING API CHANGES:
-  - None -
-
-MINOR API BEHAVIOUR CHANGES:
- - Change quaternion orientation to suit to the more common convention (-w).
- - aiString is utf8 now. Not yet consistent, however.
+----------------------------------------------------------------------
+CHANGELOG
+----------------------------------------------------------------------
+
+3.3.1 (2016-07-08)
+
+FIXES/HOUSEKEEPING:
+    - Setup of default precision for 17 exporters
+    - Fix xcode project files
+    - Fix BlenderTesselator: offsetof operator
+    - Invalid version in cmake file
+    - Update pstdint.h to latest greatest
+
+
+3.3.0 (2016-07-05)
+
+FEATURES:
+    - C++11 support enabled
+    - New regression-test-UI
+    - Experimental glTF-importer support
+    - OpenGEX: add support for cameras and lights
+    - C4D: update to latest Melange-SDK
+    - Add a gitter channel
+    - Coverity check enabled
+    - Switch to <...> include brackets for public headers 
+    - Enable export by pyAssimp
+    - CI: check windows build
+    - Add functionality to perform a singlepost-processing step
+    - many more, just check the history
+
+FIXES/HOUSEKEEPING:
+    - Fix of many resource leaks in unittests and main lib
+    - Fix iOS-buildfor X64
+    - Choosing zlib manually for cmake
+    - many more, just check the history
+
+
+3.2.1 (2016-010-10)
+
+FEATURES:
+  - Updated glTF exporter to meet 1.0 specification.
+
+FIXES/HOUSEKEEPING:
+  - Fixed glTF Validator errors for exported glTF format.
+
+ISSUES:
+  - Hard coded sampler setting for
+    - magFilter
+    - minFilter
+  - void* in ExportData for accessor max and min.
+
+
+3.2.0 (2015-11-03)
+
+FEATURES:
+  - OpenDDL-Parser is part of contrib-source.
+  - Experimental OpenGEX-support
+  - CI-check for linux and windows
+  - Coverity check added
+  - New regression testsuite.
+
+FIXES/HOUSEKEEPING:
+  - Hundreds of bugfixes  in all parts of the library
+  - Unified line endings
+
+
+API COMPATIBILITY:
+  - Removed precompiled header to increase build speed for linux
+
+
+3.1.1 (2014-06-15)
+
+FEATURES:
+   - Support for FBX 2013 and newer, binary and ASCII (this is partly
+     work from Google Summer of Code 2012)
+   - Support for OGRE binary mesh and skeleton format
+   - Updated BLEND support for newer Blender versions
+   - Support for arbitrary meta data, used to hold FBX and DAE metadata
+   - OBJ Export now produces smaller files
+   - Meshes can now have names, this is supported by the major importers
+   - Improved IFC geometry generation
+   - M3 support has been removed
+
+FIXES/HOUSEKEEPING:
+    - Hundreds of bugfixes in all parts of the library
+    - CMake is now the primary build system
+
+API COMPATIBILITY:
+    - 3.1.1 is not binary compatible to 3.0 due to aiNode::mMetaData
+      and aiMesh::mName
+    - Export interface has been cleaned up and unified
+    - Other than that no relevant changes
+
+
+3.0 (2012-07-07)
+
+FEATURES:
+   - new export interface similar to the import API.
+   - Supported export formats: Collada, OBJ, PLY and STL
+   - added new import formats: XGL/ZGL, M3 (experimental)
+   - new postprocessing steps: Debone
+   - vastly improved IFC (Industry Foundation Classes) support
+   - introduced API to query importer meta information (such as supported
+       format versions, full name, maintainer info).
+   - reworked Ogre XML import
+   - C-API now supports per-import properties
+
+FIXES/HOUSEKEEPING:
+
+   - hundreds of bugfixes in all parts of the library
+   - unified naming and cleanup of public headers
+   - improved CMake build system
+   - templatized math library
+   - reduce dependency on boost.thread, only remaining spot
+     is synchronization for the C logging API
+
+API COMPATIBILITY:
+   - renamed headers, export interface, C API properties and meta data
+     prevent compatibility with code written for 2.0, but in
+     most cases these can be easily resolved
+   - Note: 3.0 is not binary compatible with 2.0
+
+
+
+
+2.0 (2010-11-21)
+
+FEATURES:
+   - Add support for static Blender (*.blend) scenes
+   - Add support for Q3BSP scenes
+   - Add a windows-based OpenGL sample featuring texturing & basic materials
+   - Add an experimental progress feedback interface.
+   - Vastly improved performance (up to 500%, depending on mesh size and
+     spatial structure) in some expensive postprocessing steps
+   - AssimpView now uses a reworked layout which leaves more space
+     to the scene hierarchy window
+
+   - Add C# bindings ('Assimp.NET')
+   - Keep BSD-licensed and otherwise free test files in separate
+     folders (./test/models and ./test/models-nonbsd).
+
+FIXES:
+   - Many Collada bugfixes, improve fault tolerance
+   - Fix possible crashes in the Obj loader
+   - Improve the Ogre XML loader
+   - OpenGL-sample now works with MinGW
+   - Fix Importer::FindLoader failing on uppercase file extensions
+   - Fix flawed path handling when locating external files
+   - Limit the maximum number of vertices, faces, face indices and
+     weights that Assimp is able to handle. This is to avoid
+     crashes due to overflowing counters.
+
+   - Updated XCode project files
+   - Further CMAKE build improvements
+
+
+API CHANGES:
+   - Add data structures for vertex-based animations (These are not
+     currently used, however ...)
+   - Some Assimp::Importer methods are const now.
+
+
+
+
+
+1.1 (2010-04-17)
+This is the list of relevant changes from the 1.0 (r412) release to 1.1 (r700).
+
+FEATURES:
+  - Vastly improved Collada support
+  - Add MS3D (Milkshape 3D) support
+  - Add support for Ogre XML static meshes
+  - Add experimental COB (TrueSpace) support
+  - Automatic test suite to quickly locate regressions
+  - D bindings (`dAssimp`)
+  - Python 2.n bindings (`PyAssimp`)
+  - Add basic support for Unicode input files (utf8, utf16 and utf32)
+  - Add further utilities to the `assimp` tool (xml/binary dumps, quick file stats)
+  - Switch to a CMAKE-based build system including an install target for unix'es
+  - Automatic evaluation of subdivision surfaces for some formats.
+  - Add `Importer::ReadFileFromMemory` and the corresponding C-API `aiReadFileFromMemory`
+  - Expose further math utilities via the C-API (i.e. `aiMultiplyMatrix4`)
+
+  - Move noboost files away from the public include directory
+  - Many, many bugfixes and improvements in existing loaders and postprocessing steps
+  - Documentation improved and clarified in many places.
+  - Add a sample on using Assimp in conjunction with OpenGL
+
+  - Distribution/packaging: comfortable SDK installer for Windows
+  - Distribution/packaging: improved release packages for other architectures
+
+CRITICAL FIXES:
+  - Resolve problems with clashing heap managers, STL ABIs and runtime libraries (win32)
+  - Fix automatic detection of file type if no file extension is given
+  - Improved exception safety and robustness, prevent leaking of exceptions through the C interface
+  - Fix possible heap corruption due to material properties pulled in incorrectly
+  - Avoid leaking in certain error scenarios
+  - Fix 64 bit compatibility problems in some loaders (i.e. MDL)
+
+BREAKING API CHANGES:
+  - None -
+
+MINOR API BEHAVIOUR CHANGES:
+ - Change quaternion orientation to suit to the more common convention (-w).
+ - aiString is utf8 now. Not yet consistent, however.

CMakeLists.txt

@@ -168,14 +168,15 @@ IF((CMAKE_COMPILER_IS_GNUCC OR CMAKE_COMPILER_IS_GNUCXX) AND NOT CMAKE_COMPILER_
      SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
   ENDIF()
   # hide all not-exported symbols
-  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -std=c++0x" )
+  SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -fvisibility=hidden -Wall -std=c++0x" )
 ELSEIF(MSVC)
   # enable multi-core compilation with MSVC
   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" )
+  set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -g -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" )
+  SET( CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden -Wall -Wno-long-long -pedantic -std=c++11" )
+  add_definitions( -U__STRICT_ANSI__ )
 ENDIF()
 
 if (ASSIMP_COVERALLS)
@@ -184,9 +185,9 @@ if (ASSIMP_COVERALLS)
     set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g -O0 -fprofile-arcs -ftest-coverage")
 endif()
 
-INCLUDE (FindPkgConfig)
 INCLUDE_DIRECTORIES( include )
 
+INCLUDE (FindPkgMacros)
 INCLUDE (PrecompiledHeader)
 
 # If this is an in-source build (CMAKE_SOURCE_DIR == CMAKE_BINARY_DIR),
@@ -254,9 +255,7 @@ ENDIF(NOT ZLIB_FOUND)
 INCLUDE_DIRECTORIES(${ZLIB_INCLUDE_DIR})
 
 # Search for unzip
-IF (PKG_CONFIG_FOUND)
-  PKG_CHECK_MODULES(UNZIP minizip)
-ENDIF (PKG_CONFIG_FOUND)
+use_pkgconfig(UNZIP minizip)
 
 IF ( ASSIMP_NO_EXPORT )
   ADD_DEFINITIONS( -DASSIMP_BUILD_NO_EXPORT)
@@ -329,12 +328,12 @@ ENDIF (ASSIMP_BUILD_NONFREE_C4D_IMPORTER)
 
 ADD_SUBDIRECTORY( code/ )
 IF ( ASSIMP_BUILD_ASSIMP_TOOLS )
-  IF ( WIN32 )
+  IF ( WIN32 AND DirectX_D3DX9_LIBRARY )
     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 )
+  ENDIF ( WIN32 AND DirectX_D3DX9_LIBRARY )
 
   ADD_SUBDIRECTORY( tools/assimp_cmd/ )
 

CREDITS

@@ -1,160 +1,160 @@
-===============================================================
-Open Asset Import Library (Assimp)
-Developers and Contributors
-===============================================================
-
-The following is a non-exhaustive list of all constributors over the years.
-If you think your name should be listed here, drop us a line and we'll add you.
-
-- Alexander Gessler,
-3DS-, BLEND-, ASE-, DXF-, HMP-, MDL-, MD2-, MD3-, MD5-, MDC-, NFF-, PLY-, STL-, RAW-, OFF-, MS3D-, Q3D- and LWO-Loader, Assimp-Viewer, assimp-cmd, -noboost, Website (Design).
-
-- Thomas Schulze,
-X-, Collada-, BVH-Loader, Postprocessing framework. Data structure & Interface design, documentation.
-
-- Kim Kulling,
-Obj-, Q3BSD-, OpenGEX-Loader, Logging system, CMake-build-environment, Linux-build, Website ( Admin ), Coverity ( Admin ), Glitter ( Admin ).
-
-- R.Schmidt,
-Linux build, eclipse support.
-
-- Matthias Gubisch,
-Assimp.net
-Visual Studio 9 support, bugfixes.
-
-- Mark Sibly
-B3D-Loader, Assimp testing
-
-- Jonathan Klein
-Ogre Loader, VC2010 fixes and CMake fixes.
-
-- Sebastian Hempel,
-PyAssimp (first version)
-Compile-Bugfixes for mingw, add environment for static library support in make.
-
-- Jonathan Pokrass
-Supplied a bugfix concerning the scaling in the md3 loader.
-
-- Andrew Galante,
-Submitted patches to make Assimp compile with GCC-4, a makefile and the xcode3 workspace.
-
-- Andreas Nagel
-First Assimp testing & verification under Windows Vista 64 Bit.
-
-- Marius Schr�der
-Allowed us to use many of his models for screenshots and testing.
-
-- Christian Schubert
-Supplied various XFiles for testing purposes.
-
-- Tizian Wieland
-Searched the web for hundreds of test models for internal use
-
-- John Connors
-Supplied patches for linux and SCons.
-
-- T. R.
-The GUY who performed some of the CSM mocaps.
-
-- Andy Maloney
-Contributed fixes for the documentation and the doxygen markup
-
-- Zhao Lei
-Contributed several bugfixes fixing memory leaks and improving float parsing 
-
-- sueastside
-Updated PyAssimp to the latest Assimp data structures and provided a script to keep the Python binding up-to-date.
-
-- Tobias Rittig
-Collada testing with Cinema 4D
-
-- Brad Grantham
-Improvements in OpenGL-Sample.
-
-- Robert Ramirez
-Add group loading feature to Obj-Loader.
-
-- Chris Maiwald
-Many bugreports, improving Assimp's portability, regular testing & feedback.
-
-- Stepan Hrbek
-Bugreport and fix for a obj-materialloader crash.
-
-- David Nadlinger
-D bindings, CMake install support. 
-
-- Dario Accornero
-Contributed several patches regarding Mac OS/XCode targets, bug reports.
-
-- Martin Walser (Samhayne)
-Contributed the 'SimpleTexturedOpenGl' sample.
-
-- Matthias Fauconneau
-Contributed a fix for the Q3-BSP loader.
-
-- J�rgen P. Tjern�
-Contributed updated and improved xcode workspaces
-
-- drparallax
-Contributed the /samples/SimpleAssimpViewX sample
-
-- Carsten Fuchs
-Contributed a fix for the Normalize method in aiQuaternion.
-
-- dbburgess
-Contributes a Android-specific build issue: log the hardware architecture for ARM.
-
-- alfiereinre7
-Contributes a obj-fileparser fix: missing tokens in the obj-token list.
-
-- Roman Kharitonov
-Contributes a fix for the configure script environment.
-
-- Ed Diana
-Contributed AssimpDelphi (/port/AssimpDelphi).
-
-- rdb 
-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.
-
-- Rosen Diankov
-Contributed patches to build assimp debian packages using cmake.
-
-- Mark Page
-Contributed a patch to fix the VertexTriangleAdjacency postprocessing step.
-
-- IOhannes
-Contributed the Debian build fixes ( architecture macro ).
-
-- gellule
-Several LWO and LWS fixes (pivoting). 
-
-- Marcel Metz
-GCC/Linux fixes for the SimpleOpenGL sample.
-
-- Brian Miller
-Bugfix for a compiler fix for iOS on arm.
-
-- S�verin Lemaignan
-Rewrite of PyAssimp, distutils and Python3 support
-
-- albert-wang
-Bugfixes for the collada parser
-
-- Ya ping Jin
-Bugfixes for uv-tanget calculation.
-
-- Jonne Nauha
-Ogre Binary format support
-
-- Filip Wasil, Tieto Poland Sp. z o.o.
-Android JNI asset extraction support
-
-- Richard Steffen
-Contributed ExportProperties interface
-Contributed X File exporter
-Contributed Step (stp) exporter
-
-
+===============================================================
+Open Asset Import Library (Assimp)
+Developers and Contributors
+===============================================================
+
+The following is a non-exhaustive list of all constributors over the years.
+If you think your name should be listed here, drop us a line and we'll add you.
+
+- Alexander Gessler,
+3DS-, BLEND-, ASE-, DXF-, HMP-, MDL-, MD2-, MD3-, MD5-, MDC-, NFF-, PLY-, STL-, RAW-, OFF-, MS3D-, Q3D- and LWO-Loader, Assimp-Viewer, assimp-cmd, -noboost, Website (Design).
+
+- Thomas Schulze,
+X-, Collada-, BVH-Loader, Postprocessing framework. Data structure & Interface design, documentation.
+
+- Kim Kulling,
+Obj-, Q3BSD-, OpenGEX-Loader, Logging system, CMake-build-environment, Linux-build, Website ( Admin ), Coverity ( Admin ), Glitter ( Admin ).
+
+- R.Schmidt,
+Linux build, eclipse support.
+
+- Matthias Gubisch,
+Assimp.net
+Visual Studio 9 support, bugfixes.
+
+- Mark Sibly
+B3D-Loader, Assimp testing
+
+- Jonathan Klein
+Ogre Loader, VC2010 fixes and CMake fixes.
+
+- Sebastian Hempel,
+PyAssimp (first version)
+Compile-Bugfixes for mingw, add environment for static library support in make.
+
+- Jonathan Pokrass
+Supplied a bugfix concerning the scaling in the md3 loader.
+
+- Andrew Galante,
+Submitted patches to make Assimp compile with GCC-4, a makefile and the xcode3 workspace.
+
+- Andreas Nagel
+First Assimp testing & verification under Windows Vista 64 Bit.
+
+- Marius Schr�der
+Allowed us to use many of his models for screenshots and testing.
+
+- Christian Schubert
+Supplied various XFiles for testing purposes.
+
+- Tizian Wieland
+Searched the web for hundreds of test models for internal use
+
+- John Connors
+Supplied patches for linux and SCons.
+
+- T. R.
+The GUY who performed some of the CSM mocaps.
+
+- Andy Maloney
+Contributed fixes for the documentation and the doxygen markup
+
+- Zhao Lei
+Contributed several bugfixes fixing memory leaks and improving float parsing 
+
+- sueastside
+Updated PyAssimp to the latest Assimp data structures and provided a script to keep the Python binding up-to-date.
+
+- Tobias Rittig
+Collada testing with Cinema 4D
+
+- Brad Grantham
+Improvements in OpenGL-Sample.
+
+- Robert Ramirez
+Add group loading feature to Obj-Loader.
+
+- Chris Maiwald
+Many bugreports, improving Assimp's portability, regular testing & feedback.
+
+- Stepan Hrbek
+Bugreport and fix for a obj-materialloader crash.
+
+- David Nadlinger
+D bindings, CMake install support.
+
+- Dario Accornero
+Contributed several patches regarding Mac OS/XCode targets, bug reports.
+
+- Martin Walser (Samhayne)
+Contributed the 'SimpleTexturedOpenGl' sample.
+
+- Matthias Fauconneau
+Contributed a fix for the Q3-BSP loader.
+
+- Jørgen P. Tjernø
+Contributed updated and improved xcode workspaces
+
+- drparallax
+Contributed the /samples/SimpleAssimpViewX sample
+
+- Carsten Fuchs
+Contributed a fix for the Normalize method in aiQuaternion.
+
+- dbburgess
+Contributes a Android-specific build issue: log the hardware architecture for ARM.
+
+- alfiereinre7
+Contributes a obj-fileparser fix: missing tokens in the obj-token list.
+
+- Roman Kharitonov
+Contributes a fix for the configure script environment.
+
+- Ed Diana
+Contributed AssimpDelphi (/port/AssimpDelphi).
+
+- rdb
+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.
+
+- Rosen Diankov
+Contributed patches to build assimp debian packages using cmake.
+
+- Mark Page
+Contributed a patch to fix the VertexTriangleAdjacency postprocessing step.
+
+- IOhannes
+Contributed the Debian build fixes ( architecture macro ).
+
+- gellule
+Several LWO and LWS fixes (pivoting). 
+
+- Marcel Metz
+GCC/Linux fixes for the SimpleOpenGL sample.
+
+- Brian Miller
+Bugfix for a compiler fix for iOS on arm.
+
+- Séverin Lemaignan
+Rewrite of PyAssimp, distutils and Python3 support
+
+- albert-wang
+Bugfixes for the collada parser
+
+- Ya ping Jin
+Bugfixes for uv-tanget calculation.
+
+- Jonne Nauha
+Ogre Binary format support
+
+- Filip Wasil, Tieto Poland Sp. z o.o.
+Android JNI asset extraction support
+
+- Richard Steffen
+Contributed ExportProperties interface
+Contributed X File exporter
+Contributed Step (stp) exporter
+
+

LICENSE

@@ -1,78 +1,78 @@
-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.
-
-
-
-******************************************************************************
-
-AN EXCEPTION applies to all files in the ./test/models-nonbsd folder.
-These are 3d models for testing purposes, from various free sources
-on the internet. They are - unless otherwise stated - copyright of
-their respective creators, which may impose additional requirements
-on the use of their work. For any of these models, see
-<model-name>.source.txt for more legal information. Contact us if you
-are a copyright holder and believe that we credited you inproperly or
-if you don't want your files to appear in the repository.
-
-
-******************************************************************************
-
-Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
-http://code.google.com/p/poly2tri/
-
-All rights reserved.
-Redistribution and use 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 Poly2Tri nor the names of its contributors may be
-  used to endorse or promote products derived from this software without specific
-  prior written permission.
-
-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.
+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.
+
+
+
+******************************************************************************
+
+AN EXCEPTION applies to all files in the ./test/models-nonbsd folder.
+These are 3d models for testing purposes, from various free sources
+on the internet. They are - unless otherwise stated - copyright of
+their respective creators, which may impose additional requirements
+on the use of their work. For any of these models, see
+<model-name>.source.txt for more legal information. Contact us if you
+are a copyright holder and believe that we credited you inproperly or
+if you don't want your files to appear in the repository.
+
+
+******************************************************************************
+
+Poly2Tri Copyright (c) 2009-2010, Poly2Tri Contributors
+http://code.google.com/p/poly2tri/
+
+All rights reserved.
+Redistribution and use 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 Poly2Tri nor the names of its contributors may be
+  used to endorse or promote products derived from this software without specific
+  prior written permission.
+
+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.

Readme.md

@@ -1,140 +1,148 @@
-Open Asset Import Library (assimp)
-==================================
-
-APIs are provided for C and C++. There are various bindings to other languages (C#, Java, Python, Delphi, D). Assimp also runs on Android and iOS.
-
-Additionally, assimp features various __mesh post processing tools__: normals and tangent space generation, triangulation, vertex cache locality optimization, removal of degenerate primitives and duplicate vertices, sorting by primitive type, merging of redundant materials and many more.
-
-This is the development trunk containing the latest features and bugfixes. For productive use though, we recommend one of the stable releases available from [assimp.sf.net](http://assimp.sf.net) or from *nix package repositories.
-The current build status is:
-
-Linux [![Linux Build Status](https://travis-ci.org/assimp/assimp.png)](https://travis-ci.org/assimp/assimp)
-Windows [![Windows Build Status](https://ci.appveyor.com/api/projects/status/tmo433wax6u6cjp4?svg=true)](https://ci.appveyor.com/project/kimkulling/assimp)
-Coverity<a href="https://scan.coverity.com/projects/5607">
-  <img alt="Coverity Scan Build Status"
-       src="https://scan.coverity.com/projects/5607/badge.svg"/>
-</a>
-<br>
-Code coverage:[![Coverage Status](https://coveralls.io/repos/github/assimp/assimp/badge.svg?branch=master)](https://coveralls.io/github/assimp/assimp?branch=master)
-<br>
-Gitter chat: [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
-__[open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities.__
-
-#### Supported file formats ####
-
-A full list [is here](http://assimp.sourceforge.net/main_features_formats.html).
-__Importers__:
-
-- 3DS
-- BLEND (Blender)
-- DAE/Collada
-- FBX
-- IFC-STEP
-- ASE
-- DXF
-- HMP
-- MD2
-- MD3
-- MD5
-- MDC
-- MDL
-- NFF
-- PLY
-- STL
-- X
-- OBJ
-- OpenGEX
-- SMD
-- LWO
-- LXO
-- LWS  
-- TER
-- AC3D
-- MS3D
-- COB
-- Q3BSP
-- XGL
-- CSM
-- BVH
-- B3D
-- NDO
-- Ogre Binary
-- Ogre XML
-- Q3D
-- ASSBIN (Assimp custom format)
-- glTF (partial)
-- 3MF
-
-Additionally, some formats are supported by dependency on non-free code or external SDKs (not built by default):
-
-- C4D (https://github.com/acgessler/assimp-cinema4d)
-
-__Exporters__:
-
-- DAE (Collada)
-- STL
-- OBJ
-- PLY
-- X
-- 3DS
-- JSON (for WebGl, via https://github.com/acgessler/assimp2json)
-- ASSBIN
-- 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.
-
-### Ports ###
-* [Android](port/AndroidJNI/README.md)
-* [Python](port/PyAssimp/README.md)
-* [.NET](port/AssimpNET/Readme.md)
-* [Pascal](port/AssimpPascal/Readme.md)
-
-#### Repository structure ####
-Open Asset Import Library is implemented in C++. The directory structure is:
-
-	/code		Source code
-	/contrib	Third-party libraries
-	/doc		Documentation (doxysource and pre-compiled docs)
-	/include	Public header C and C++ header files
-	/scripts 	Scripts used to generate the loading code for some formats
-	/port		Ports to other languages and scripts to maintain those.
-	/test		Unit- and regression tests, test suite of models
-	/tools		Tools (old assimp viewer, command line `assimp`)
-	/samples	A small number of samples to illustrate possible
-                        use cases for Assimp
-	/workspaces	Build environments for vc,xcode,... (deprecated,
-			CMake has superseeded all legacy build options!)
-
-
-### Where to get help ###
-For more information, visit [our website](http://assimp.sourceforge.net/). Or check out the `./doc`- folder, which contains the official documentation in HTML format.
-(CHMs for Windows are included in some release packages and should be located right here in the root folder).
-
-If the docs don't solve your problem, ask on [StackOverflow](http://stackoverflow.com/questions/tagged/assimp?sort=newest). If you think you found a bug, please open an issue on Github.
-
-For development discussions, there is also a (very low-volume) mailing list, _assimp-discussions_
-  [(subscribe here)]( https://lists.sourceforge.net/lists/listinfo/assimp-discussions)
-
-Open Asset Import Library is a library to load various 3d file formats into a shared, in-memory format. It supports more than __40 file formats__ for import and a growing selection of file formats for export.
-
-And we also have a Gitter-channel:Gitter [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
-
-### Contributing ###
-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.
-
-An _informal_ summary is: do whatever you want, but include Assimp's license text with your product -
-and don't sue us if our code doesn't work. Note that, unlike LGPLed code, you may link statically to Assimp.
-For the legal details, see the `LICENSE` file.
-
-### Why this name ###
-Sorry, we're germans :-), no english native speakers ...
+Open Asset Import Library (assimp)
+==================================
+
+[![Linux Build Status](https://travis-ci.org/assimp/assimp.svg)](https://travis-ci.org/assimp/assimp)
+[![Windows Build Status](https://ci.appveyor.com/api/projects/status/tmo433wax6u6cjp4?svg=true)](https://ci.appveyor.com/project/kimkulling/assimp)
+<a href="https://scan.coverity.com/projects/5607">
+  <img alt="Coverity Scan Build Status"
+       src="https://scan.coverity.com/projects/5607/badge.svg"/>
+</a>
+[![Coverage Status](https://coveralls.io/repos/github/assimp/assimp/badge.svg?branch=master)](https://coveralls.io/github/assimp/assimp?branch=master)
+<br>
+
+APIs are provided for C and C++. There are various bindings to other languages (C#, Java, Python, Delphi, D). Assimp also runs on Android and iOS.
+
+Additionally, assimp features various __mesh post processing tools__: normals and tangent space generation, triangulation, vertex cache locality optimization, removal of degenerate primitives and duplicate vertices, sorting by primitive type, merging of redundant materials and many more.
+
+This is the development trunk containing the latest features and bugfixes. For productive use though, we recommend one of the stable releases available from [assimp.sf.net](http://assimp.sf.net) or from *nix package repositories.
+The current build status is:
+
+Gitter chat: [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
+
+And we also have an IRC-channel at freenode: #assetimporterlib . You can easily join us via: [KiwiIRC/freenote](https://kiwiirc.com/client/irc.freenode.net), choose your nickname and type
+> /join #assetimporterlib
+
+<br>
+__[open3mod](https://github.com/acgessler/open3mod) is a powerful 3D model viewer based on Assimp's import and export abilities.__
+
+Please check our Wiki as well: https://github.com/assimp/assimp/wiki
+
+#### Supported file formats ####
+
+A full list [is here](http://assimp.org/main_features_formats.html).
+__Importers__:
+
+- 3DS
+- BLEND (Blender)
+- DAE/Collada
+- FBX
+- IFC-STEP
+- ASE
+- DXF
+- HMP
+- MD2
+- MD3
+- MD5
+- MDC
+- MDL
+- NFF
+- PLY
+- STL
+- X
+- OBJ
+- OpenGEX
+- SMD
+- LWO
+- LXO
+- LWS  
+- TER
+- AC3D
+- MS3D
+- COB
+- Q3BSP
+- XGL
+- CSM
+- BVH
+- B3D
+- NDO
+- Ogre Binary
+- Ogre XML
+- Q3D
+- ASSBIN (Assimp custom format)
+- glTF (partial)
+- 3MF
+
+Additionally, some formats are supported by dependency on non-free code or external SDKs (not built by default):
+
+- C4D (https://github.com/acgessler/assimp-cinema4d)
+
+__Exporters__:
+
+- DAE (Collada)
+- STL
+- OBJ
+- PLY
+- X
+- 3DS
+- JSON (for WebGl, via https://github.com/acgessler/assimp2json)
+- ASSBIN
+- 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.
+
+### Ports ###
+* [Android](port/AndroidJNI/README.md)
+* [Python](port/PyAssimp/README.md)
+* [.NET](port/AssimpNET/Readme.md)
+* [Pascal](port/AssimpPascal/Readme.md)
+* [Javascript (Alpha)](https://github.com/makc/assimp2json)
+
+#### Repository structure ####
+Open Asset Import Library is implemented in C++. The directory structure is:
+
+	/code		Source code
+	/contrib	Third-party libraries
+	/doc		Documentation (doxysource and pre-compiled docs)
+	/include	Public header C and C++ header files
+	/scripts 	Scripts used to generate the loading code for some formats
+	/port		Ports to other languages and scripts to maintain those.
+	/test		Unit- and regression tests, test suite of models
+	/tools		Tools (old assimp viewer, command line `assimp`)
+	/samples	A small number of samples to illustrate possible
+                        use cases for Assimp
+	/workspaces	Build environments for vc,xcode,... (deprecated,
+			CMake has superseeded all legacy build options!)
+
+
+### Where to get help ###
+For more information, visit [our website](http://assimp.org/). Or check out the `./doc`- folder, which contains the official documentation in HTML format.
+(CHMs for Windows are included in some release packages and should be located right here in the root folder).
+
+If the docs don't solve your problem, ask on [StackOverflow](http://stackoverflow.com/questions/tagged/assimp?sort=newest). If you think you found a bug, please open an issue on Github.
+
+For development discussions, there is also a (very low-volume) mailing list, _assimp-discussions_
+  [(subscribe here)]( https://lists.sourceforge.net/lists/listinfo/assimp-discussions)
+
+Open Asset Import Library is a library to load various 3d file formats into a shared, in-memory format. It supports more than __40 file formats__ for import and a growing selection of file formats for export.
+
+And we also have a Gitter-channel:Gitter [![Join the chat at https://gitter.im/assimp/assimp](https://badges.gitter.im/assimp/assimp.svg)](https://gitter.im/assimp/assimp?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)<br>
+
+### Contributing ###
+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.
+
+An _informal_ summary is: do whatever you want, but include Assimp's license text with your product -
+and don't sue us if our code doesn't work. Note that, unlike LGPLed code, you may link statically to Assimp.
+For the legal details, see the `LICENSE` file.
+
+### Why this name ###
+Sorry, we're germans :-), no english native speakers ...

appveyor.yml

@@ -27,7 +27,7 @@ install:
 # Make compiler command line tools available
 - call c:\projects\assimp\scripts\appveyor\compiler_setup.bat
 
-build_script:  
+build_script:
 - cd c:\projects\assimp
 - if "%platform%" equ "x64" (cmake CMakeLists.txt -G "Visual Studio %Configuration% Win64")
 - if "%platform%" equ "x86" (cmake CMakeLists.txt -G "Visual Studio %Configuration%")
@@ -40,4 +40,3 @@ after_build:
 artifacts:
   - path: assimp.7z
     name: assimp_lib
-

cmake-modules/FindPkgMacros.cmake

@@ -59,10 +59,13 @@ endmacro(clear_if_changed)
 
 # Try to get some hints from pkg-config, if available
 macro(use_pkgconfig PREFIX PKGNAME)
-  find_package(PkgConfig)
-  if (PKG_CONFIG_FOUND)
-    pkg_check_modules(${PREFIX} ${PKGNAME})
-  endif ()
+  # Android does not support PKG_CONFIG so we disable it
+  IF ( NOT ANDROID )
+    find_package(PkgConfig)
+    if (PKG_CONFIG_FOUND)
+      pkg_check_modules(${PREFIX} ${PKGNAME})
+    endif ()
+  ENDIF ( NOT ANDROID )
 endmacro (use_pkgconfig)
 
 # Couple a set of release AND debug libraries (or frameworks)

cmake-modules/FindZLIB.cmake

@@ -11,7 +11,7 @@
 # Once done, this will define
 #
 #  ZLIB_FOUND - system has ZLIB
-#  ZLIB_INCLUDE_DIRS - the ZLIB include directories 
+#  ZLIB_INCLUDE_DIRS - the ZLIB include directories
 #  ZLIB_LIBRARIES - link these to use ZLIB
 
 include(FindPkgMacros)

code/3DSConverter.cpp

@@ -690,7 +690,7 @@ void Discreet3DSImporter::AddNodeToGraph(aiScene* pcSOut,aiNode* pcOut,
     pcOut->mChildren = new aiNode*[pcIn->mChildren.size()];
 
     // Recursively process all children
-    const unsigned int size = pcIn->mChildren.size();
+    const unsigned int size = static_cast<unsigned int>(pcIn->mChildren.size());
     for (unsigned int i = 0; i < size;++i)
     {
         pcOut->mChildren[i] = new aiNode();
@@ -742,7 +742,7 @@ void Discreet3DSImporter::GenerateNodeGraph(aiScene* pcOut)
         DefaultLogger::get()->warn("No hierarchy information has been found in the file. ");
 
         pcOut->mRootNode->mNumChildren = pcOut->mNumMeshes +
-            mScene->mCameras.size() + mScene->mLights.size();
+            static_cast<unsigned int>(mScene->mCameras.size() + mScene->mLights.size());
 
         pcOut->mRootNode->mChildren = new aiNode* [ pcOut->mRootNode->mNumChildren ];
         pcOut->mRootNode->mName.Set("<3DSDummyRoot>");

code/3DSExporter.cpp

@@ -87,7 +87,7 @@ namespace {
             const std::size_t chunk_size = head_pos - chunk_start_pos;
 
             writer.SetCurrentPos(chunk_start_pos + SIZE_OFFSET);
-            writer.PutU4(chunk_size);
+            writer.PutU4(static_cast<uint32_t>(chunk_size));
             writer.SetCurrentPos(head_pos);
         }
 

code/3DSExporter.h

@@ -48,7 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <memory>
 
 #include "StreamWriter.h"
-#include "./../include/assimp/material.h"
+#include <assimp/material.h>
 
 struct aiScene;
 struct aiNode;

code/3DSHelper.h

@@ -48,10 +48,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "SmoothingGroups.h"
 #include "StringUtils.h"
 #include "qnan.h"
-#include "./../include/assimp/material.h"
-#include "./../include/assimp/camera.h"
-#include "./../include/assimp/light.h"
-#include "./../include/assimp/anim.h"
+#include <assimp/material.h>
+#include <assimp/camera.h>
+#include <assimp/light.h>
+#include <assimp/anim.h>
 #include <stdio.h> //sprintf
 
 namespace Assimp    {

code/3DSLoader.cpp

@@ -54,6 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
+#include <assimp/importerdesc.h>
 #include "StringComparison.h"
 
 using namespace Assimp;
@@ -182,7 +183,7 @@ void Discreet3DSImporter::InternReadFile( const std::string& pFile,
     ParseMainChunk();
 
     // Process all meshes in the file. First check whether all
-    // face indices haev valid values. The generate our
+    // face indices have valid values. The generate our
     // internal verbose representation. Finally compute normal
     // vectors from the smoothing groups we read from the
     // file.
@@ -679,7 +680,7 @@ void Discreet3DSImporter::ParseHierarchyChunk(uint16_t parent)
 
         if ( pcNode)
         {
-            // if the source is not a CHUNK_TRACKINFO block it wont be an object instance
+            // if the source is not a CHUNK_TRACKINFO block it won't be an object instance
             if (parent != Discreet3DS::CHUNK_TRACKINFO)
             {
                 mCurrentNode = pcNode;

code/ACLoader.cpp

@@ -60,6 +60,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/config.h>
 #include <assimp/IOSystem.hpp>
+#include <assimp/importerdesc.h>
 #include <memory>
 
 using namespace Assimp;

code/AMFImporter.cpp

@@ -51,11 +51,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "AMFImporter_Macro.hpp"
 
 #include "fast_atof.h"
-#include "DefaultIOSystem.h"
+#include <assimp/DefaultIOSystem.h>
 
 // Header files, stdlib.
 #include <memory>
-#include <string>
 
 namespace Assimp
 {
@@ -188,15 +187,15 @@ void AMFImporter::XML_CheckNode_MustHaveChildren()
 
 void AMFImporter::XML_CheckNode_SkipUnsupported(const std::string& pParentNodeName)
 {
-const size_t Uns_Skip_Len = 3;
-const char* Uns_Skip[Uns_Skip_Len] = { "composite", "edge", "normal" };
+    static const size_t Uns_Skip_Len = 3;
+    const char* Uns_Skip[Uns_Skip_Len] = { "composite", "edge", "normal" };
 
-static bool skipped_before[Uns_Skip_Len] = { false, false, false };
+    static bool skipped_before[Uns_Skip_Len] = { false, false, false };
 
-std::string nn(mReader->getNodeName());
-bool found = false;
-bool close_found = false;
-size_t sk_idx;
+    std::string nn(mReader->getNodeName());
+    bool found = false;
+    bool close_found = false;
+    size_t sk_idx;
 
 	for(sk_idx = 0; sk_idx < Uns_Skip_Len; sk_idx++)
 	{
@@ -245,7 +244,7 @@ bool AMFImporter::XML_SearchNode(const std::string& pNodeName)
 
 bool AMFImporter::XML_ReadNode_GetAttrVal_AsBool(const int pAttrIdx)
 {
-std::string val(mReader->getAttributeValue(pAttrIdx));
+    std::string val(mReader->getAttributeValue(pAttrIdx));
 
 	if((val == "false") || (val == "0"))
 		return false;
@@ -257,8 +256,8 @@ std::string val(mReader->getAttributeValue(pAttrIdx));
 
 float AMFImporter::XML_ReadNode_GetAttrVal_AsFloat(const int pAttrIdx)
 {
-std::string val;
-float tvalf;
+    std::string val;
+    float tvalf;
 
 	ParseHelper_FixTruncatedFloatString(mReader->getAttributeValue(pAttrIdx), val);
 	fast_atoreal_move(val.c_str(), tvalf, false);
@@ -273,8 +272,8 @@ uint32_t AMFImporter::XML_ReadNode_GetAttrVal_AsU32(const int pAttrIdx)
 
 float AMFImporter::XML_ReadNode_GetVal_AsFloat()
 {
-std::string val;
-float tvalf;
+    std::string val;
+    float tvalf;
 
 	if(!mReader->read()) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. No data, seems file is corrupt.");
 	if(mReader->getNodeType() != irr::io::EXN_TEXT) throw DeadlyImportError("XML_ReadNode_GetVal_AsFloat. Invalid type of XML element, seems file is corrupt.");
@@ -320,7 +319,7 @@ void AMFImporter::ParseHelper_Node_Exit()
 
 void AMFImporter::ParseHelper_FixTruncatedFloatString(const char* pInStr, std::string& pOutString)
 {
-size_t instr_len;
+    size_t instr_len;
 
 	pOutString.clear();
 	instr_len = strlen(pInStr);
@@ -352,12 +351,12 @@ static bool ParseHelper_Decode_Base64_IsBase64(const char pChar)
 
 void AMFImporter::ParseHelper_Decode_Base64(const std::string& pInputBase64, std::vector<uint8_t>& pOutputData) const
 {
-// With help from
-// RenИ Nyffenegger http://www.adp-gmbh.ch/cpp/common/base64.html
-const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+    // With help from
+    // René Nyffenegger http://www.adp-gmbh.ch/cpp/common/base64.html
+    const std::string base64_chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
-uint8_t tidx = 0;
-uint8_t arr4[4], arr3[3];
+    uint8_t tidx = 0;
+    uint8_t arr4[4], arr3[3];
 
 	// check input data
 	if(pInputBase64.size() % 4) throw DeadlyImportError("Base64-encoded data must have size multiply of four.");
@@ -402,8 +401,8 @@ uint8_t arr4[4], arr3[3];
 
 void AMFImporter::ParseFile(const std::string& pFile, IOSystem* pIOHandler)
 {
-irr::io::IrrXMLReader* OldReader = mReader;// store current XMLreader.
-std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
+    irr::io::IrrXMLReader* OldReader = mReader;// store current XMLreader.
+    std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 
 	// Check whether we can read from the file
 	if(file.get() == NULL) throw DeadlyImportError("Failed to open AMF file " + pFile + ".");
@@ -434,8 +433,8 @@ std::unique_ptr<IOStream> file(pIOHandler->Open(pFile, "rb"));
 // Multi elements - No.
 void AMFImporter::ParseNode_Root()
 {
-std::string unit, version;
-CAMFImporter_NodeElement* ne;
+    std::string unit, version;
+    CAMFImporter_NodeElement *ne( nullptr );
 
 	// Read attributes for node <amf>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -481,8 +480,8 @@ CAMFImporter_NodeElement* ne;
 // Parent element - <amf>.
 void AMFImporter::ParseNode_Constellation()
 {
-std::string id;
-CAMFImporter_NodeElement* ne;
+    std::string id;
+    CAMFImporter_NodeElement* ne( nullptr );
 
 	// Read attributes for node <constellation>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -522,8 +521,8 @@ CAMFImporter_NodeElement* ne;
 // Parent element - <amf>.
 void AMFImporter::ParseNode_Instance()
 {
-std::string objectid;
-CAMFImporter_NodeElement* ne;
+    std::string objectid;
+    CAMFImporter_NodeElement* ne( nullptr );
 
 	// Read attributes for node <constellation>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -577,8 +576,8 @@ CAMFImporter_NodeElement* ne;
 // Parent element - <amf>.
 void AMFImporter::ParseNode_Object()
 {
-std::string id;
-CAMFImporter_NodeElement* ne;
+    std::string id;
+    CAMFImporter_NodeElement* ne( nullptr );
 
 	// Read attributes for node <object>.
 	MACRO_ATTRREAD_LOOPBEG;
@@ -642,8 +641,8 @@ CAMFImporter_NodeElement* ne;
 // "Volume" - specifies the total volume of the entity, in the entity's unit system, to be used for verification (object and volume only)
 void AMFImporter::ParseNode_Metadata()
 {
-std::string type, value;
-CAMFImporter_NodeElement* ne;
+    std::string type, value;
+    CAMFImporter_NodeElement* ne( nullptr );
 
 	// read attribute
 	MACRO_ATTRREAD_LOOPBEG;
@@ -665,15 +664,17 @@ CAMFImporter_NodeElement* ne;
 
 bool AMFImporter::CanRead(const std::string& pFile, IOSystem* pIOHandler, bool pCheckSig) const
 {
-const std::string extension = GetExtension(pFile);
+    const std::string extension = GetExtension(pFile);
 
-	if(extension == "amf") return true;
+    if ( extension == "amf" ) {
+        return true;
+    }
 
 	if(!extension.length() || pCheckSig)
 	{
-		const char* tokens[] = { "<?xml", "<amf" };
+		const char* tokens[] = { "<amf" };
 
-		return SearchFileHeaderForToken(pIOHandler, pFile, tokens, 2);
+		return SearchFileHeaderForToken( pIOHandler, pFile, tokens, 1 );
 	}
 
 	return false;

code/AMFImporter.hpp

@@ -52,9 +52,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "AMFImporter_Node.hpp"
 
 // Header files, Assimp.
-#include "assimp/DefaultLogger.hpp"
-#include "assimp/importerdesc.h"
-#include "assimp/ProgressHandler.hpp"
+#include <assimp/DefaultLogger.hpp>
+#include <assimp/importerdesc.h>
 #include "assimp/types.h"
 #include "BaseImporter.h"
 #include "irrXMLWrapper.h"
@@ -135,18 +134,18 @@ private:
 	};
 
 	/// \struct SPP_Texture
-	/// Data type for postprocessing step. More suitable container for texture.
+	/// Data type for post-processing step. More suitable container for texture.
 	struct SPP_Texture
 	{
 		std::string ID;
-		size_t Width, Height, Depth;
-		bool Tiled;
-		decltype(aiTexture::achFormatHint) FormatHint;
-		uint8_t* Data;
+		size_t      Width, Height, Depth;
+		bool        Tiled;
+        char        FormatHint[ 9 ];// 8 for string + 1 for terminator.
+		uint8_t    *Data;
 	};
 
 	///	\struct SComplexFace
-	/// Data type for postprocessing step. Contain face data.
+	/// Data type for post-processing step. Contain face data.
 	struct SComplexFace
 	{
 		aiFace Face;///< Face vertices.

code/AMFImporter_Postprocess.cpp

@@ -54,7 +54,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "StringUtils.h"
 
 // Header files, stdlib.
-#include <algorithm>
 #include <iterator>
 
 namespace Assimp
@@ -62,7 +61,7 @@ namespace Assimp
 
 aiColor4D AMFImporter::SPP_Material::GetColor(const float pX, const float pY, const float pZ) const
 {
-aiColor4D tcol;
+    aiColor4D tcol;
 
 	// Check if stored data are supported.
 	if(Composition.size() != 0)
@@ -93,8 +92,8 @@ aiColor4D tcol;
 void AMFImporter::PostprocessHelper_CreateMeshDataArray(const CAMFImporter_NodeElement_Mesh& pNodeElement, std::vector<aiVector3D>& pVertexCoordinateArray,
 														std::vector<CAMFImporter_NodeElement_Color*>& pVertexColorArray) const
 {
-CAMFImporter_NodeElement_Vertices* vn = nullptr;
-size_t col_idx;
+    CAMFImporter_NodeElement_Vertices* vn = nullptr;
+    size_t col_idx;
 
 	// All data stored in "vertices", search for it.
 	for(CAMFImporter_NodeElement* ne_child: pNodeElement.Child)
@@ -142,8 +141,8 @@ size_t col_idx;
 size_t AMFImporter::PostprocessHelper_GetTextureID_Or_Create(const std::string& pID_R, const std::string& pID_G, const std::string& pID_B,
 																const std::string& pID_A)
 {
-size_t TextureConverted_Index;
-std::string TextureConverted_ID;
+    size_t TextureConverted_Index;
+    std::string TextureConverted_ID;
 
 	// check input data
 	if(pID_R.empty() && pID_G.empty() && pID_B.empty() && pID_A.empty())
@@ -261,11 +260,20 @@ std::string TextureConverted_ID;
 	size_t off_b = 0;
 
 	// Calculate size of the target array and rule how data will be copied.
-	if(!pID_R.empty()) { tex_size += src_texture[0]->Data.size(); step++, off_g++, off_b++; }
-	if(!pID_G.empty()) { tex_size += src_texture[1]->Data.size(); step++, off_b++; }
-	if(!pID_B.empty()) { tex_size += src_texture[2]->Data.size(); step++; }
-	if(!pID_A.empty()) { tex_size += src_texture[3]->Data.size(); step++; }
-
+    if ( nullptr != src_texture ) {
+        if(!pID_R.empty()) {
+            tex_size += src_texture[0]->Data.size(); step++, off_g++, off_b++;
+        }
+        if(!pID_G.empty()) {
+            tex_size += src_texture[1]->Data.size(); step++, off_b++;
+        }
+        if(!pID_B.empty()) {
+            tex_size += src_texture[2]->Data.size(); step++;
+        }
+        if(!pID_A.empty()) {
+            tex_size += src_texture[3]->Data.size(); step++;
+        }
+    }
 	// Create target array.
 	converted_texture.Data = new uint8_t[tex_size];
 	// And copy data
@@ -293,19 +301,19 @@ std::string TextureConverted_ID;
 
 void AMFImporter::PostprocessHelper_SplitFacesByTextureID(std::list<SComplexFace>& pInputList, std::list<std::list<SComplexFace> >& pOutputList_Separated)
 {
-auto texmap_is_equal = [](const CAMFImporter_NodeElement_TexMap* pTexMap1, const CAMFImporter_NodeElement_TexMap* pTexMap2) -> bool
-{
-	if((pTexMap1 == nullptr) && (pTexMap2 == nullptr)) return true;
-	if(pTexMap1 == nullptr) return false;
-	if(pTexMap2 == nullptr) return false;
+    auto texmap_is_equal = [](const CAMFImporter_NodeElement_TexMap* pTexMap1, const CAMFImporter_NodeElement_TexMap* pTexMap2) -> bool
+    {
+	    if((pTexMap1 == nullptr) && (pTexMap2 == nullptr)) return true;
+	    if(pTexMap1 == nullptr) return false;
+	    if(pTexMap2 == nullptr) return false;
 
-	if(pTexMap1->TextureID_R != pTexMap2->TextureID_R) return false;
-	if(pTexMap1->TextureID_G != pTexMap2->TextureID_G) return false;
-	if(pTexMap1->TextureID_B != pTexMap2->TextureID_B) return false;
-	if(pTexMap1->TextureID_A != pTexMap2->TextureID_A) return false;
+	    if(pTexMap1->TextureID_R != pTexMap2->TextureID_R) return false;
+	    if(pTexMap1->TextureID_G != pTexMap2->TextureID_G) return false;
+	    if(pTexMap1->TextureID_B != pTexMap2->TextureID_B) return false;
+	    if(pTexMap1->TextureID_A != pTexMap2->TextureID_A) return false;
 
-	return true;
-};
+	    return true;
+    };
 
 	pOutputList_Separated.clear();
 	if(pInputList.size() == 0) return;
@@ -343,12 +351,12 @@ void AMFImporter::Postprocess_AddMetadata(const std::list<CAMFImporter_NodeEleme
 		if(sceneNode.mMetaData != nullptr) throw DeadlyImportError("Postprocess. MetaData member in node are not nullptr. Something went wrong.");
 
 		// copy collected metadata to output node.
-        sceneNode.mMetaData = aiMetadata::Alloc( metadataList.size() );
+        sceneNode.mMetaData = aiMetadata::Alloc( static_cast<unsigned int>(metadataList.size()) );
 		size_t meta_idx( 0 );
 
 		for(const CAMFImporter_NodeElement_Metadata& metadata: metadataList)
 		{
-			sceneNode.mMetaData->Set(meta_idx++, metadata.Type, aiString(metadata.Value));
+			sceneNode.mMetaData->Set(static_cast<unsigned int>(meta_idx++), metadata.Type, aiString(metadata.Value));
 		}
 	}// if(!metadataList.empty())
 }
@@ -437,9 +445,9 @@ std::list<unsigned int> mesh_idx;
 					// create new face and store it.
 					complex_face.Face.mNumIndices = 3;
 					complex_face.Face.mIndices = new unsigned int[3];
-					complex_face.Face.mIndices[0] = tri_al.V[0];
-					complex_face.Face.mIndices[1] = tri_al.V[1];
-					complex_face.Face.mIndices[2] = tri_al.V[2];
+					complex_face.Face.mIndices[0] = static_cast<unsigned int>(tri_al.V[0]);
+					complex_face.Face.mIndices[1] = static_cast<unsigned int>(tri_al.V[1]);
+					complex_face.Face.mIndices[2] = static_cast<unsigned int>(tri_al.V[2]);
 					complex_faces_list.push_back(complex_face);
 				}
 			}// for(const CAMFImporter_NodeElement* ne_volume_child: ne_volume->Child)
@@ -508,7 +516,7 @@ std::list<unsigned int> mesh_idx;
 					{
 						for(size_t vi = 0; vi < face.Face.mNumIndices; vi++)
 						{
-							if(face.Face.mIndices[vi] == pIdx_From) face.Face.mIndices[vi] = pIdx_To;
+							if(face.Face.mIndices[vi] == pIdx_From) face.Face.mIndices[vi] = static_cast<unsigned int>(pIdx_To);
 						}
 					}
 				};// auto VertexIndex_Replace = [](std::list<SComplexFace>& pFaceList, const size_t pIdx_From, const size_t pIdx_To) -> void
@@ -563,7 +571,7 @@ std::list<unsigned int> mesh_idx;
 				// set geometry and colors (vertices)
 				//
 				// copy faces/triangles
-				tmesh->mNumFaces = face_list_cur.size();
+				tmesh->mNumFaces = static_cast<unsigned int>(face_list_cur.size());
 				tmesh->mFaces = new aiFace[tmesh->mNumFaces];
 
 				// Create vertices list and optimize indices. Optimisation mean following.In AMF all volumes use one big list of vertices. And one volume
@@ -590,7 +598,7 @@ std::list<unsigned int> mesh_idx;
 					do
 					{
 						vert_idx_from = VertexIndex_GetMinimal(face_list_cur, &vert_idx_to);
-						if(vert_idx_from == vert_idx_to) break;// all indices are transfered,
+						if(vert_idx_from == vert_idx_to) break;// all indices are transferred,
 
 						vert_arr.push_back(pVertexCoordinateArray.at(vert_idx_from));
 						col_arr.push_back(Vertex_CalculateColor(vert_idx_from));
@@ -619,7 +627,7 @@ std::list<unsigned int> mesh_idx;
 						{
 							vert_arr.push_back(vert_arr.at(face_cur.Face.mIndices[idx_ind]));
 							col_arr.push_back(face_color);
-							face_cur.Face.mIndices[idx_ind] = vert_idx_new++;
+							face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(vert_idx_new++);
 						}
 					}// if(face_cur.Color != nullptr)
 				}// for(const SComplexFace& face_cur: face_list_cur)
@@ -639,10 +647,10 @@ std::list<unsigned int> mesh_idx;
 					for(size_t i = 0, i_e = VertexCount_Max * 2; i < i_e; i++) idx_vert_used[i] = false;
 
 					// This ID's will be used when set materials ID in scene.
-					tmesh->mMaterialIndex = PostprocessHelper_GetTextureID_Or_Create(face_list_cur.front().TexMap->TextureID_R,
+					tmesh->mMaterialIndex = static_cast<unsigned int>(PostprocessHelper_GetTextureID_Or_Create(face_list_cur.front().TexMap->TextureID_R,
 																						face_list_cur.front().TexMap->TextureID_G,
 																						face_list_cur.front().TexMap->TextureID_B,
-																						face_list_cur.front().TexMap->TextureID_A);
+																						face_list_cur.front().TexMap->TextureID_A));
 					texcoord_arr.resize(VertexCount_Max * 2);
 					for(const SComplexFace& face_cur: face_list_cur)
 					{
@@ -662,7 +670,7 @@ std::list<unsigned int> mesh_idx;
 								vert_arr.push_back(vert_arr.at(idx_vert));
 								col_arr.push_back(col_arr.at(idx_vert));
 								texcoord_arr.at(idx_vert_new) = face_cur.TexMap->TextureCoordinate[idx_ind];
-								face_cur.Face.mIndices[idx_ind] = idx_vert_new++;
+								face_cur.Face.mIndices[idx_ind] = static_cast<unsigned int>(idx_vert_new++);
 							}
 						}// for(size_t idx_ind = 0; idx_ind < face_cur.Face.mNumIndices; idx_ind++)
 					}// for(const SComplexFace& face_cur: face_list_cur)
@@ -675,7 +683,7 @@ std::list<unsigned int> mesh_idx;
 				//
 				// copy collected data to mesh
 				//
-				tmesh->mNumVertices = vert_arr.size();
+				tmesh->mNumVertices = static_cast<unsigned int>(vert_arr.size());
 				tmesh->mVertices = new aiVector3D[tmesh->mNumVertices];
 				tmesh->mColors[0] = new aiColor4D[tmesh->mNumVertices];
 				tmesh->mFaces = new aiFace[face_list_cur.size()];
@@ -693,7 +701,7 @@ std::list<unsigned int> mesh_idx;
 				for(const SComplexFace& face_cur: face_list_cur) tmesh->mFaces[idx_face++] = face_cur.Face;
 
 				// store new aiMesh
-				mesh_idx.push_back(pMeshList.size());
+				mesh_idx.push_back(static_cast<unsigned int>(pMeshList.size()));
 				pMeshList.push_back(tmesh);
 			}// for(const std::list<SComplexFace>& face_list_cur: complex_faces_toplist)
 		}// if(ne_child->Type == CAMFImporter_NodeElement::ENET_Volume)
@@ -704,7 +712,7 @@ std::list<unsigned int> mesh_idx;
 	{
 		std::list<unsigned int>::const_iterator mit = mesh_idx.begin();
 
-		pSceneNode.mNumMeshes = mesh_idx.size();
+		pSceneNode.mNumMeshes = static_cast<unsigned int>(mesh_idx.size());
 		pSceneNode.mMeshes = new unsigned int[pSceneNode.mNumMeshes];
 		for(size_t i = 0; i < pSceneNode.mNumMeshes; i++) pSceneNode.mMeshes[i] = *mit++;
 	}// if(mesh_idx.size() > 0)
@@ -743,7 +751,7 @@ std::list<aiNode*> ch_node;
 	//  \_ aiNode for transformation (<instance> -> <delta...>, <r...>) - aiNode for pointing to object ("objectid")
 	con_node = new aiNode;
 	con_node->mName = pConstellation.ID;
-	// Walk thru children and search for instances of another objects, constellations.
+	// Walk through children and search for instances of another objects, constellations.
 	for(const CAMFImporter_NodeElement* ne: pConstellation.Child)
 	{
 		aiMatrix4x4 tmat;
@@ -779,7 +787,7 @@ std::list<aiNode*> ch_node;
 
 	size_t ch_idx = 0;
 
-	con_node->mNumChildren = ch_node.size();
+	con_node->mNumChildren = static_cast<unsigned int>(ch_node.size());
 	con_node->mChildren = new aiNode*[con_node->mNumChildren];
 	for(aiNode* node: ch_node) con_node->mChildren[ch_idx++] = node;
 
@@ -815,7 +823,7 @@ std::list<CAMFImporter_NodeElement_Metadata*> meta_list;
 	// Check if root element are found.
 	if(root_el == nullptr) throw DeadlyImportError("Root(<amf>) element not found.");
 
-	// after that walk thru children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
+	// after that walk through children of root and collect data. Five types of nodes can be placed at top level - in <amf>: <object>, <material>, <texture>,
 	// <constellation> and <metadata>. But at first we must read <material> and <texture> because they will be used in <object>. <metadata> can be read
 	// at any moment.
 	//
@@ -870,7 +878,7 @@ nl_clean_loop:
 
 	if(node_list.size() > 1)
 	{
-		// walk thru all nodes
+		// walk through all nodes
 		for(std::list<aiNode*>::iterator nl_it = node_list.begin(); nl_it != node_list.end(); nl_it++)
 		{
 			// and try to find them in another top nodes.
@@ -899,7 +907,7 @@ nl_clean_loop:
 	{
 		std::list<aiNode*>::const_iterator nl_it = node_list.begin();
 
-		pScene->mRootNode->mNumChildren = node_list.size();
+		pScene->mRootNode->mNumChildren = static_cast<unsigned int>(node_list.size());
 		pScene->mRootNode->mChildren = new aiNode*[pScene->mRootNode->mNumChildren];
 		for(size_t i = 0; i < pScene->mRootNode->mNumChildren; i++)
 		{
@@ -916,14 +924,14 @@ nl_clean_loop:
 	{
 		std::list<aiMesh*>::const_iterator ml_it = mesh_list.begin();
 
-		pScene->mNumMeshes = mesh_list.size();
+		pScene->mNumMeshes = static_cast<unsigned int>(mesh_list.size());
 		pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
 		for(size_t i = 0; i < pScene->mNumMeshes; i++) pScene->mMeshes[i] = *ml_it++;
 	}// if(mesh_list.size() > 0)
 
 	//
 	// Textures
-	pScene->mNumTextures = mTexture_Converted.size();
+	pScene->mNumTextures = static_cast<unsigned int>(mTexture_Converted.size());
 	if(pScene->mNumTextures > 0)
 	{
 		size_t idx;
@@ -933,8 +941,8 @@ nl_clean_loop:
 		for(const SPP_Texture& tex_convd: mTexture_Converted)
 		{
 			pScene->mTextures[idx] = new aiTexture;
-			pScene->mTextures[idx]->mWidth = tex_convd.Width;
-			pScene->mTextures[idx]->mHeight = tex_convd.Height;
+			pScene->mTextures[idx]->mWidth = static_cast<unsigned int>(tex_convd.Width);
+			pScene->mTextures[idx]->mHeight = static_cast<unsigned int>(tex_convd.Height);
 			pScene->mTextures[idx]->pcData = (aiTexel*)tex_convd.Data;
 			// texture format description.
 			strcpy(pScene->mTextures[idx]->achFormatHint, tex_convd.FormatHint);
@@ -943,7 +951,7 @@ nl_clean_loop:
 
 		// Create materials for embedded textures.
 		idx = 0;
-		pScene->mNumMaterials = mTexture_Converted.size();
+		pScene->mNumMaterials = static_cast<unsigned int>(mTexture_Converted.size());
 		pScene->mMaterials = new aiMaterial*[pScene->mNumMaterials];
 		for(const SPP_Texture& tex_convd: mTexture_Converted)
 		{
@@ -959,7 +967,7 @@ nl_clean_loop:
 			idx++;
 		}
 	}// if(pScene->mNumTextures > 0)
-}// END: after that walk thru children of root and collect data
+}// END: after that walk through children of root and collect data
 
 }// namespace Assimp
 

code/ASELoader.cpp

@@ -54,6 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
+#include <assimp/importerdesc.h>
 
 #include <memory>
 

code/ASELoader.h

@@ -46,9 +46,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "BaseImporter.h"
 #include <assimp/types.h>
+#include "ASEParser.h"
 
 struct aiNode;
-#include "ASEParser.h"
 
 namespace Assimp {
 

code/ASEParser.cpp

@@ -49,7 +49,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 // internal headers
 #include "TextureTransform.h"
 #include "ASELoader.h"
-#include "MaterialSystem.h"
 #include "fast_atof.h"
 #include <assimp/DefaultLogger.hpp>
 
@@ -1135,7 +1134,7 @@ void Parser::ParseLV3ScaleAnimationBlock(ASE::Animation& anim)
             bool b = false;
 
             // For the moment we're just reading the three floats -
-            // we ignore the �dditional information for bezier's and TCBs
+            // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
             if (TokenMatch(filePtr,"CONTROL_SCALE_SAMPLE" ,20))
@@ -1181,7 +1180,7 @@ void Parser::ParseLV3PosAnimationBlock(ASE::Animation& anim)
             bool b = false;
 
             // For the moment we're just reading the three floats -
-            // we ignore the �dditional information for bezier's and TCBs
+            // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
             if (TokenMatch(filePtr,"CONTROL_POS_SAMPLE" ,18))
@@ -1227,7 +1226,7 @@ void Parser::ParseLV3RotAnimationBlock(ASE::Animation& anim)
             bool b = false;
 
             // For the moment we're just reading the  floats -
-            // we ignore the �dditional information for bezier's and TCBs
+            // we ignore the additional information for bezier's and TCBs
 
             // simple scaling keyframe
             if (TokenMatch(filePtr,"CONTROL_ROT_SAMPLE" ,18))
@@ -1858,7 +1857,7 @@ void Parser::ParseLV3MeshCFaceListBlock(unsigned int iNumFaces, ASE::Mesh& mesh)
             ++filePtr;
 
             // Face entry
-            if (TokenMatch(filePtr,"MESH_CFACE" ,11))
+            if (TokenMatch(filePtr,"MESH_CFACE" ,10))
             {
                 unsigned int aiValues[3];
                 unsigned int iIndex = 0;

code/AssbinExporter.cpp

@@ -737,7 +737,7 @@ inline size_t WriteArray(IOStream * stream, const T* in, unsigned int size)
                 AssbinChunkWriter uncompressedStream( NULL, 0 );
                 WriteBinaryScene( &uncompressedStream, pScene );
 
-                uLongf uncompressedSize = uncompressedStream.Tell();
+                uLongf uncompressedSize = static_cast<uLongf>(uncompressedStream.Tell());
                 uLongf compressedSize = (uLongf)(uncompressedStream.Tell() * 1.001 + 12.);
                 uint8_t* compressedBuffer = new uint8_t[ compressedSize ];
 

code/AssbinLoader.cpp

@@ -54,6 +54,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/mesh.h>
 #include <assimp/anim.h>
 #include <assimp/scene.h>
+#include <assimp/importerdesc.h>
 
 #ifdef ASSIMP_BUILD_NO_OWN_ZLIB
 #   include <zlib.h>
@@ -659,7 +660,7 @@ void AssbinImporter::InternReadFile( const std::string& pFile, aiScene* pScene,
     if (compressed)
     {
         uLongf uncompressedSize = Read<uint32_t>(stream);
-        uLongf compressedSize = stream->FileSize() - stream->Tell();
+        uLongf compressedSize = static_cast<uLongf>(stream->FileSize() - stream->Tell());
 
         unsigned char * compressedData = new unsigned char[ compressedSize ];
         stream->Read( compressedData, 1, compressedSize );

code/AssbinLoader.h

@@ -46,7 +46,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_ASSBINIMPORTER_H_INC
 
 #include "BaseImporter.h"
-#include <assimp/types.h>
 
 struct aiMesh;
 struct aiNode;

code/Assimp.cpp

@@ -150,7 +150,7 @@ void ReportSceneNotFoundError()
     DefaultLogger::get()->error("Unable to find the Assimp::Importer for this aiScene. "
         "The C-API does not accept scenes produced by the C++ API and vice versa");
 
-    assert(false);
+    ai_assert(false);
 }
 
 // ------------------------------------------------------------------------------------------------

code/AssxmlExporter.cpp

@@ -41,7 +41,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  ASSXML exporter main code
  */
 #include <stdarg.h>
-#include "./../include/assimp/version.h"
+#include <assimp/version.h>
 #include "ProcessHelper.h"
 #include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
@@ -72,7 +72,7 @@ static int ioprintf( IOStream * io, const char *format, ... ) {
         return -1;
     }
 
-    static const size_t Size = 4096;
+    static const int Size = 4096;
     char sz[ Size ];
     ::memset( sz, '\0', Size );
     va_list va;

code/B3DImporter.cpp

@@ -56,7 +56,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/anim.h>
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
-
+#include <assimp/importerdesc.h>
 
 using namespace Assimp;
 using namespace std;
@@ -331,7 +331,7 @@ void B3DImporter::ReadVRTS(){
     int sz=12+(_vflags&1?12:0)+(_vflags&2?16:0)+(_tcsets*_tcsize*4);
     int n_verts=ChunkSize()/sz;
 
-    int v0=_vertices.size();
+    int v0=static_cast<int>(_vertices.size());
     _vertices.resize( v0+n_verts );
 
     for( int i=0;i<n_verts;++i ){
@@ -404,7 +404,7 @@ void B3DImporter::ReadTRIS( int v0 ){
 void B3DImporter::ReadMESH(){
     /*int matid=*/ReadInt();
 
-    int v0=_vertices.size();
+    int v0= static_cast<int>(_vertices.size());
 
     while( ChunkSize() ){
         string t=ReadChunk();
@@ -462,17 +462,17 @@ void B3DImporter::ReadKEYS( aiNodeAnim *nodeAnim ){
     }
 
     if( flags & 1 ){
-        nodeAnim->mNumPositionKeys=trans.size();
+        nodeAnim->mNumPositionKeys=static_cast<unsigned int>(trans.size());
         nodeAnim->mPositionKeys=to_array( trans );
     }
 
     if( flags & 2 ){
-        nodeAnim->mNumScalingKeys=scale.size();
+        nodeAnim->mNumScalingKeys=static_cast<unsigned int>(scale.size());
         nodeAnim->mScalingKeys=to_array( scale );
     }
 
     if( flags & 4 ){
-        nodeAnim->mNumRotationKeys=rot.size();
+        nodeAnim->mNumRotationKeys=static_cast<unsigned int>(rot.size());
         nodeAnim->mRotationKeys=to_array( rot );
     }
 }
@@ -506,7 +506,7 @@ aiNode *B3DImporter::ReadNODE( aiNode *parent ){
 
     aiMatrix4x4 tform=trans * rot * scale;
 
-    int nodeid=_nodes.size();
+    int nodeid=static_cast<int>(_nodes.size());
 
     aiNode *node=new aiNode( name );
     _nodes.push_back( node );
@@ -521,9 +521,9 @@ aiNode *B3DImporter::ReadNODE( aiNode *parent ){
     while( ChunkSize() ){
         string t=ReadChunk();
         if( t=="MESH" ){
-            int n=_meshes.size();
+            unsigned int n= static_cast<unsigned int>(_meshes.size());
             ReadMESH();
-            for( int i=n;i<(int)_meshes.size();++i ){
+            for( unsigned int i=n;i<static_cast<unsigned int>(_meshes.size());++i ){
                 meshes.push_back( i );
             }
         }else if( t=="BONE" ){
@@ -544,10 +544,10 @@ aiNode *B3DImporter::ReadNODE( aiNode *parent ){
         ExitChunk();
     }
 
-    node->mNumMeshes=meshes.size();
+    node->mNumMeshes= static_cast<unsigned int>(meshes.size());
     node->mMeshes=to_array( meshes );
 
-    node->mNumChildren=children.size();
+    node->mNumChildren=static_cast<unsigned int>(children.size());
     node->mChildren=to_array( children );
 
     return node;
@@ -645,7 +645,7 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
                 aiNode *bnode=_nodes[i];
 
                 bone->mName=bnode->mName;
-                bone->mNumWeights=weights.size();
+                bone->mNumWeights= static_cast<unsigned int>(weights.size());
                 bone->mWeights=to_array( weights );
 
                 aiMatrix4x4 mat=bnode->mTransformation;
@@ -655,7 +655,7 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
                 }
                 bone->mOffsetMatrix=mat.Inverse();
             }
-            mesh->mNumBones=bones.size();
+            mesh->mNumBones= static_cast<unsigned int>(bones.size());
             mesh->mBones=to_array( bones );
         }
     }
@@ -667,21 +667,21 @@ void B3DImporter::ReadBB3D( aiScene *scene ){
     if( !_materials.size() ){
         _materials.push_back( new aiMaterial );
     }
-    scene->mNumMaterials=_materials.size();
+    scene->mNumMaterials= static_cast<unsigned int>(_materials.size());
     scene->mMaterials=to_array( _materials );
 
     //meshes
-    scene->mNumMeshes=_meshes.size();
+    scene->mNumMeshes= static_cast<unsigned int>(_meshes.size());
     scene->mMeshes=to_array( _meshes );
 
     //animations
     if( _animations.size()==1 && _nodeAnims.size() ){
 
         aiAnimation *anim=_animations.back();
-        anim->mNumChannels=_nodeAnims.size();
+        anim->mNumChannels=static_cast<unsigned int>(_nodeAnims.size());
         anim->mChannels=to_array( _nodeAnims );
 
-        scene->mNumAnimations=_animations.size();
+        scene->mNumAnimations=static_cast<unsigned int>(_animations.size());
         scene->mAnimations=to_array( _animations );
     }
 

code/B3DImporter.h

@@ -48,7 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/material.h>
 #include "BaseImporter.h"
 
-#include <string>
 #include <vector>
 
 struct aiNodeAnim;

code/BVHLoader.cpp

@@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "TinyFormatter.h"
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
+#include <assimp/importerdesc.h>
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -237,7 +238,7 @@ aiNode* BVHLoader::ReadNode()
     // add the child nodes if there are any
     if( childNodes.size() > 0)
     {
-        node->mNumChildren = childNodes.size();
+        node->mNumChildren = static_cast<unsigned int>(childNodes.size());
         node->mChildren = new aiNode*[node->mNumChildren];
         std::copy( childNodes.begin(), childNodes.end(), node->mChildren);
     }
@@ -443,7 +444,7 @@ void BVHLoader::CreateAnimation( aiScene* pScene)
     anim->mDuration = double( mAnimNumFrames - 1);
 
     // now generate the tracks for all nodes
-    anim->mNumChannels = mNodes.size();
+    anim->mNumChannels = static_cast<unsigned int>(mNodes.size());
     anim->mChannels = new aiNodeAnim*[anim->mNumChannels];
 
     // FIX: set the array elements to NULL to ensure proper deletion if an exception is thrown

code/BaseImporter.cpp

@@ -50,6 +50,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/Importer.hpp>
 #include <assimp/postprocess.h>
+#include <assimp/importerdesc.h>
 #include <ios>
 #include <list>
 #include <memory>
@@ -136,14 +137,17 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions)
 }
 
 // ------------------------------------------------------------------------------------------------
-/*static*/ bool BaseImporter::SearchFileHeaderForToken(IOSystem* pIOHandler,
+/*static*/ bool BaseImporter::SearchFileHeaderForToken( IOSystem* pIOHandler,
     const std::string&  pFile,
     const char**        tokens,
     unsigned int        numTokens,
     unsigned int        searchBytes /* = 200 */,
     bool                tokensSol /* false */)
 {
-    ai_assert(NULL != tokens && 0 != numTokens && 0 != searchBytes);
+    ai_assert( NULL != tokens );
+    ai_assert( 0 != numTokens );
+    ai_assert( 0 != searchBytes);
+
     if (!pIOHandler)
         return false;
 
@@ -178,8 +182,6 @@ void BaseImporter::GetExtensionList(std::set<std::string>& extensions)
 
         for (unsigned int i = 0; i < numTokens;++i) {
             ai_assert(NULL != tokens[i]);
-
-
             const char* r = strstr(buffer,tokens[i]);
             if( !r ) {
                 continue;

code/BaseImporter.h

@@ -44,14 +44,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "Exceptional.h"
 
-#include <string>
-#include <map>
 #include <vector>
 #include <set>
 #include <assimp/types.h>
 #include <assimp/ProgressHandler.hpp>
 
 struct aiScene;
+struct aiImporterDesc;
 
 namespace Assimp    {
 

code/BaseProcess.h

@@ -43,8 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_BASEPROCESS_H
 
 #include <map>
-
-#include <assimp/types.h>
 #include "GenericProperty.h"
 
 struct aiScene;

code/Bitmap.h

@@ -50,93 +50,71 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <stdint.h>
 #include <cstddef>
+
 struct aiTexture;
 
 namespace Assimp {
 
 class IOStream;
-class Bitmap {
-
-    protected:
-
-        struct Header {
-
-            uint16_t type;
-
-            uint32_t size;
-
-            uint16_t reserved1;
-
-            uint16_t reserved2;
-
-            uint32_t offset;
-
-            // We define the struct size because sizeof(Header) might return a wrong result because of structure padding.
-            // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
-            static const std::size_t header_size =
-                sizeof(uint16_t) + // type
-                sizeof(uint32_t) + // size
-                sizeof(uint16_t) + // reserved1
-                sizeof(uint16_t) + // reserved2
-                sizeof(uint32_t);  // offset
-
-        };
-
-        struct DIB {
-
-            uint32_t size;
-
-            int32_t width;
-
-            int32_t height;
-
-            uint16_t planes;
-
-            uint16_t bits_per_pixel;
-
-            uint32_t compression;
-
-            uint32_t image_size;
-
-            int32_t x_resolution;
-
-            int32_t y_resolution;
-
-            uint32_t nb_colors;
-
-            uint32_t nb_important_colors;
-
-            // We define the struct size because sizeof(DIB) might return a wrong result because of structure padding.
-            // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
-            static const std::size_t dib_size =
-                sizeof(uint32_t) + // size
-                sizeof(int32_t) +  // width
-                sizeof(int32_t) +  // height
-                sizeof(uint16_t) + // planes
-                sizeof(uint16_t) + // bits_per_pixel
-                sizeof(uint32_t) + // compression
-                sizeof(uint32_t) + // image_size
-                sizeof(int32_t) +  // x_resolution
-                sizeof(int32_t) +  // y_resolution
-                sizeof(uint32_t) + // nb_colors
-                sizeof(uint32_t);  // nb_important_colors
-
-        };
-
-        static const std::size_t mBytesPerPixel = 4;
-
-    public:
-
-        static void Save(aiTexture* texture, IOStream* file);
-
-    protected:
-
-        static void WriteHeader(Header& header, IOStream* file);
-
-        static void WriteDIB(DIB& dib, IOStream* file);
-
-        static void WriteData(aiTexture* texture, IOStream* file);
 
+class Bitmap {
+protected:
+
+    struct Header {
+        uint16_t type;
+        uint32_t size;
+        uint16_t reserved1;
+        uint16_t reserved2;
+        uint32_t offset;
+
+        // We define the struct size because sizeof(Header) might return a wrong result because of structure padding.
+        // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
+        static const std::size_t header_size =
+            sizeof(uint16_t) + // type
+            sizeof(uint32_t) + // size
+            sizeof(uint16_t) + // reserved1
+            sizeof(uint16_t) + // reserved2
+            sizeof(uint32_t);  // offset
+    };
+
+    struct DIB {
+        uint32_t size;
+        int32_t width;
+        int32_t height;
+        uint16_t planes;
+        uint16_t bits_per_pixel;
+        uint32_t compression;
+        uint32_t image_size;
+        int32_t x_resolution;
+        int32_t y_resolution;
+        uint32_t nb_colors;
+        uint32_t nb_important_colors;
+
+        // We define the struct size because sizeof(DIB) might return a wrong result because of structure padding.
+        // Moreover, we must use this ugly and error prone syntax because Visual Studio neither support constexpr or sizeof(name_of_field).
+        static const std::size_t dib_size =
+            sizeof(uint32_t) + // size
+            sizeof(int32_t) +  // width
+            sizeof(int32_t) +  // height
+            sizeof(uint16_t) + // planes
+            sizeof(uint16_t) + // bits_per_pixel
+            sizeof(uint32_t) + // compression
+            sizeof(uint32_t) + // image_size
+            sizeof(int32_t) +  // x_resolution
+            sizeof(int32_t) +  // y_resolution
+            sizeof(uint32_t) + // nb_colors
+            sizeof(uint32_t);  // nb_important_colors
+    };
+
+    static const std::size_t mBytesPerPixel = 4;
+
+public:
+    static void Save(aiTexture* texture, IOStream* file);
+
+protected:
+    static void WriteHeader(Header& header, IOStream* file);
+    static void WriteDIB(DIB& dib, IOStream* file);
+    static void WriteData(aiTexture* texture, IOStream* file);
 };
 
 }

code/BlenderBMesh.cpp

@@ -180,7 +180,7 @@ void BlenderBMeshConverter::AddFace( int v1, int v2, int v3, int v4 )
     // TODO - Work out how materials work
     face.mat_nr = 0;
     triMesh->mface.push_back( face );
-    triMesh->totface = triMesh->mface.size( );
+    triMesh->totface = static_cast<int>(triMesh->mface.size( ));
 }
 
 // ------------------------------------------------------------------------------------------------

code/BlenderDNA.cpp

@@ -48,6 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderDNA.h"
 #include "StreamReader.h"
 #include "fast_atof.h"
+#include "TinyFormatter.h"
 
 using namespace Assimp;
 using namespace Assimp::Blender;

code/BlenderDNA.h

@@ -46,12 +46,11 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_BLEND_DNA_H
 
 #include "BaseImporter.h"
-#include "TinyFormatter.h"
 #include "StreamReader.h"
 #include <assimp/DefaultLogger.hpp>
 #include <stdint.h>
 #include <memory>
-
+#include <map>
 
 // enable verbose log output. really verbose, so be careful.
 #ifdef ASSIMP_BUILD_DEBUG

code/BlenderDNA.inl

@@ -46,9 +46,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_BLEND_DNA_INL
 
 #include <memory>
+#include "TinyFormatter.h"
 
 namespace Assimp {
-    namespace Blender {
+namespace Blender {
 
 //--------------------------------------------------------------------------------
 const Field& Structure :: operator [] (const std::string& ss) const

code/BlenderIntermediate.h

@@ -48,9 +48,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderLoader.h"
 #include "BlenderDNA.h"
 #include "BlenderScene.h"
-#include "BlenderSceneGen.h"
 #include <deque>
-#include "./../include/assimp/material.h"
+#include <assimp/material.h>
 
 struct aiTexture;
 

code/BlenderLoader.cpp

@@ -54,10 +54,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BlenderBMesh.h"
 #include "StringUtils.h"
 #include <assimp/scene.h>
-#include "StringComparison.h"
+#include <assimp/importerdesc.h>
 
+#include "StringComparison.h"
 #include "StreamReader.h"
 #include "MemoryIOWrapper.h"
+
 #include <cctype>
 
 
@@ -95,8 +97,9 @@ static const aiImporterDesc blenderDesc = {
 // ------------------------------------------------------------------------------------------------
 // Constructor to be privately used by Importer
 BlenderImporter::BlenderImporter()
-: modifier_cache(new BlenderModifierShowcase())
-{}
+: modifier_cache(new BlenderModifierShowcase()) {
+    // empty
+}
 
 // ------------------------------------------------------------------------------------------------
 // Destructor, private as well
@@ -144,8 +147,7 @@ void BlenderImporter::SetupProperties(const Importer* /*pImp*/)
     // nothing to be done for the moment
 }
 
-struct free_it
-{
+struct free_it {
     free_it(void* free) : free(free) {}
     ~free_it() {
         ::free(this->free);
@@ -164,6 +166,7 @@ void BlenderImporter::InternReadFile( const std::string& pFile,
     free_it free_it_really(dest);
 #endif
 
+
     FileDatabase file;
     std::shared_ptr<IOStream> stream(pIOHandler->Open(pFile,"rb"));
     if (!stream) {
@@ -423,7 +426,7 @@ void BlenderImporter::ResolveImage(aiMaterial* out, const Material* mat, const M
     // check if the file contents are bundled with the BLEND file
     if (img->packedfile) {
         name.data[0] = '*';
-        name.length = 1+ ASSIMP_itoa10(name.data+1,MAXLEN-1,conv_data.textures->size());
+        name.length = 1+ ASSIMP_itoa10(name.data+1,static_cast<unsigned int>(MAXLEN-1), static_cast<int32_t>(conv_data.textures->size()));
 
         conv_data.textures->push_back(new aiTexture());
         aiTexture* tex = conv_data.textures->back();
@@ -1230,7 +1233,7 @@ aiNode* BlenderImporter::ConvertNode(const Scene& in, const Object* obj, Convers
             if (conv_data.meshes->size() > old) {
                 node->mMeshes = new unsigned int[node->mNumMeshes = static_cast<unsigned int>(conv_data.meshes->size()-old)];
                 for (unsigned int i = 0; i < node->mNumMeshes; ++i) {
-                    node->mMeshes[i] = i + old;
+                    node->mMeshes[i] = static_cast<unsigned int>(i + old);
                 }
             }}
             break;

code/BlenderScene.cpp

@@ -44,9 +44,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_BLEND_IMPORTER
 
-#include "BlenderDNA.h"
 #include "BlenderScene.h"
 #include "BlenderSceneGen.h"
+#include "BlenderDNA.h"
 
 using namespace Assimp;
 using namespace Assimp::Blender;
@@ -522,7 +522,7 @@ template <> void Structure :: Convert<MVert> (
     ReadFieldArray<ErrorPolicy_Fail>(dest.co,"co",db);
     ReadFieldArray<ErrorPolicy_Fail>(dest.no,"no",db);
     ReadField<ErrorPolicy_Igno>(dest.flag,"flag",db);
-    ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
+    //ReadField<ErrorPolicy_Warn>(dest.mat_nr,"mat_nr",db);
     ReadField<ErrorPolicy_Igno>(dest.bweight,"bweight",db);
 
     db.reader->IncPtr(size);

code/BlenderScene.h

@@ -616,6 +616,17 @@ struct Object : ElemBase  {
     std::shared_ptr<ElemBase> data FAIL;
 
     ListBase modifiers;
+
+    Object()
+    : ElemBase()
+    , type( Type_EMPTY )
+    , parent( nullptr )
+    , track()
+    , proxy()
+    , proxy_from()
+    , data() {
+        // empty
+    }
 };
 
 
@@ -624,6 +635,14 @@ struct Base : ElemBase {
     Base* prev WARN;
     std::shared_ptr<Base> next WARN;
     std::shared_ptr<Object> object WARN;
+
+    Base() 
+    : ElemBase()
+    , next()
+    , object() {
+        // empty
+        // empty
+    }
 };
 
 // -------------------------------------------------------------------------------
@@ -635,8 +654,15 @@ struct Scene : ElemBase {
     std::shared_ptr<Base> basact WARN;
 
     ListBase base;
-};
 
+    Scene()
+    : ElemBase()
+    , camera()
+    , world()
+    , basact() {
+        // empty
+    }
+};
 
 // -------------------------------------------------------------------------------
 struct Image : ElemBase {
@@ -664,6 +690,11 @@ struct Image : ElemBase {
     short animspeed;
 
     short gen_x, gen_y, gen_type;
+    
+    Image()
+    : ElemBase() {
+        // empty
+    }
 };
 
 // -------------------------------------------------------------------------------
@@ -751,6 +782,12 @@ struct Tex : ElemBase {
     //VoxelData *vd;
 
     //char use_nodes;
+
+    Tex()
+    : ElemBase() {
+        // empty
+    }
+
 };
 
 // -------------------------------------------------------------------------------
@@ -839,9 +876,13 @@ struct MTex : ElemBase {
     //float lifefac, sizefac, ivelfac, pvelfac;
     //float shadowfac;
     //float zenupfac, zendownfac, blendfac;
-};
-
 
+    MTex()
+    : ElemBase() {
+        // empty
     }
+};
+
+}
 }
 #endif

code/BlenderTessellator.cpp

@@ -412,9 +412,9 @@ float BlenderTessellatorP2T::FindLargestMatrixElem( const aiMatrix3x3& mtx ) con
 {
     float result = 0.0f;
 
-    for ( size_t x = 0; x < 3; ++x )
+    for ( unsigned int x = 0; x < 3; ++x )
     {
-        for ( size_t y = 0; y < 3; ++y )
+        for ( unsigned int y = 0; y < 3; ++y )
         {
             result = p2tMax( std::fabs( mtx[ x ][ y ] ), result );
         }
@@ -429,9 +429,9 @@ aiMatrix3x3 BlenderTessellatorP2T::ScaleMatrix( const aiMatrix3x3& mtx, float sc
 {
     aiMatrix3x3 result;
 
-    for ( size_t x = 0; x < 3; ++x )
+    for ( unsigned int x = 0; x < 3; ++x )
     {
-        for ( size_t y = 0; y < 3; ++y )
+        for ( unsigned int y = 0; y < 3; ++y )
         {
             result[ x ][ y ] = mtx[ x ][ y ] * scale;
         }

code/BlobIOSystem.h

@@ -45,10 +45,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_BLOBIOSYSTEM_H_INCLUDED
 #define AI_BLOBIOSYSTEM_H_INCLUDED
 
-#include "./../include/assimp/IOStream.hpp"
-#include "./../include/assimp/cexport.h"
-#include "./../include/assimp/IOSystem.hpp"
-#include "./../include/assimp/DefaultLogger.hpp"
+#include <assimp/IOStream.hpp>
+#include <assimp/cexport.h>
+#include <assimp/IOSystem.hpp>
+#include <assimp/DefaultLogger.hpp>
 #include <stdint.h>
 #include <set>
 #include <vector>

code/CMakeLists.txt

@@ -93,6 +93,8 @@ SET( PUBLIC_HEADERS
   ${HEADER_PATH}/NullLogger.hpp
   ${HEADER_PATH}/cexport.h
   ${HEADER_PATH}/Exporter.hpp
+  ${HEADER_PATH}/DefaultIOStream.h
+  ${HEADER_PATH}/DefaultIOSystem.h
 )
 
 SET( Core_SRCS
@@ -125,9 +127,7 @@ SET( Common_SRCS
   ByteSwapper.h
   DefaultProgressHandler.h
   DefaultIOStream.cpp
-  DefaultIOStream.h
   DefaultIOSystem.cpp
-  DefaultIOSystem.h
   CInterfaceIOWrapper.cpp
   CInterfaceIOWrapper.h
   Hash.h
@@ -163,6 +163,7 @@ SET( Common_SRCS
   RemoveComments.h
   Subdivision.cpp
   Subdivision.h
+  scene.cpp
   Vertex.h
   LineSplitter.h
   TinyFormatter.h
@@ -173,6 +174,8 @@ SET( Common_SRCS
   XMLTools.h
   Version.cpp
   IOStreamBuffer.h
+  CreateAnimMesh.h
+  CreateAnimMesh.cpp
 )
 SOURCE_GROUP(Common FILES ${Common_SRCS})
 
@@ -184,10 +187,16 @@ IF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
   SOURCE_GROUP( C4D FILES ${C4D_SRCS})
 ENDIF ( ASSIMP_BUILD_NONFREE_C4D_IMPORTER )
 
+# if this variable is set to TRUE, the user can manually disable importers by setting
+# ASSIMP_BUILD_XXX_IMPORTER to FALSE for each importer
+# if this variable is set to FALSE, the user can manually enable importers by setting
+# ASSIMP_BUILD_XXX_IMPORTER to TRUE for each importer
+OPTION(ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT "default value of all ASSIMP_BUILD_XXX_IMPORTER value" TRUE)
+
 # macro to add the CMake Option ADD_ASSIMP_IMPORTER_<name> which enables compile of loader
 # this way selective loaders can be compiled (reduces filesize + compile time)
 MACRO(ADD_ASSIMP_IMPORTER name)
-  OPTION(ASSIMP_BUILD_${name}_IMPORTER "build the ${name} importer" TRUE)
+  OPTION(ASSIMP_BUILD_${name}_IMPORTER "build the ${name} importer" ${ASSIMP_BUILD_ALL_IMPORTERS_BY_DEFAULT})
   IF(ASSIMP_BUILD_${name}_IMPORTER)
     LIST(APPEND ASSIMP_LOADER_SRCS ${ARGN})
     SET(ASSIMP_IMPORTERS_ENABLED "${ASSIMP_IMPORTERS_ENABLED} ${name}")
@@ -197,6 +206,7 @@ MACRO(ADD_ASSIMP_IMPORTER name)
     SET(${name}_SRC "")
     SET(ASSIMP_IMPORTERS_DISABLED "${ASSIMP_IMPORTERS_DISABLED} ${name}")
     add_definitions(-DASSIMP_BUILD_NO_${name}_IMPORTER)
+    add_definitions(-DASSIMP_BUILD_NO_${name}_EXPORTER)
   ENDIF()
 ENDMACRO()
 
@@ -462,9 +472,13 @@ ADD_ASSIMP_IMPORTER( IFC
   STEPFileEncoding.cpp
   STEPFileEncoding.h
 )
-if (MSVC AND ASSIMP_BUILD_IFC_IMPORTER)
-  set_source_files_properties(IFCReaderGen1.cpp IFCReaderGen2.cpp PROPERTIES COMPILE_FLAGS "/bigobj")
-endif (MSVC AND ASSIMP_BUILD_IFC_IMPORTER)
+if (ASSIMP_BUILD_IFC_IMPORTER)
+  if (MSVC)
+    set_source_files_properties(IFCReaderGen1.cpp IFCReaderGen2.cpp PROPERTIES COMPILE_FLAGS "/bigobj")
+  elseif(CMAKE_COMPILER_IS_MINGW)
+    set_source_files_properties(IFCReaderGen1.cpp IFCReaderGen2.cpp PROPERTIES COMPILE_FLAGS "-O2 -Wa,-mbig-obj")
+  endif()
+endif (ASSIMP_BUILD_IFC_IMPORTER)
 
 ADD_ASSIMP_IMPORTER( XGL
   XGLLoader.cpp
@@ -642,7 +656,6 @@ ADD_ASSIMP_IMPORTER( GLTF
   glTFExporter.cpp
 )
 
-
 ADD_ASSIMP_IMPORTER( 3MF
     D3MFImporter.h
     D3MFImporter.cpp

code/COBLoader.cpp

@@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
-
+#include <assimp/importerdesc.h>
 
 using namespace Assimp;
 using namespace Assimp::COB;
@@ -181,7 +181,7 @@ void COBImporter::InternReadFile( const std::string& pFile,
         if (n->type == Node::TYPE_MESH) {
             Mesh& mesh = (Mesh&)(*n.get());
             if (mesh.vertex_positions.size() && mesh.texture_coords.size()) {
-                pScene->mNumMeshes += mesh.temp_map.size();
+                pScene->mNumMeshes += static_cast<unsigned int>(mesh.temp_map.size());
             }
         }
     }

code/COBScene.h

@@ -46,12 +46,13 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <memory>
 #include <deque>
+#include <map>
 
 #include "BaseImporter.h"
-#include "./../include/assimp/material.h"
+#include <assimp/material.h>
 
-namespace Assimp    {
-    namespace COB {
+namespace Assimp {
+namespace COB {
 
 // ------------------
 /** Represents a single vertex index in a face */

code/CSMLoader.cpp

@@ -57,7 +57,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/anim.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
-
+#include <assimp/importerdesc.h>
 
 using namespace Assimp;
 
@@ -179,7 +179,7 @@ void CSMImporter::InternReadFile( const std::string& pFile,
                     nda->mNodeName.length = (size_t)(ot-nda->mNodeName.data);
                 }
 
-                anim->mNumChannels = anims_temp.size();
+                anim->mNumChannels = static_cast<unsigned int>(anims_temp.size());
                 if (!anim->mNumChannels)
                     throw DeadlyImportError("CSM: Empty $order section");
 

code/ColladaExporter.cpp

@@ -38,18 +38,16 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
-
-
 #ifndef ASSIMP_BUILD_NO_EXPORT
 #ifndef ASSIMP_BUILD_NO_COLLADA_EXPORTER
-#include "ColladaExporter.h"
 
+#include "ColladaExporter.h"
 #include "Bitmap.h"
 #include "fast_atof.h"
 #include "SceneCombiner.h"
-#include "DefaultIOSystem.h"
 #include "StringUtils.h"
 #include "XMLTools.h"
+#include <assimp/DefaultIOSystem.h>
 #include <assimp/IOSystem.hpp>
 #include <assimp/Exporter.hpp>
 #include <assimp/scene.h>
@@ -384,6 +382,7 @@ void ColladaExporter::WriteLight(size_t pIndex){
         case aiLightSource_SPOT:
             WriteSpotLight(light);
             break;
+        case aiLightSource_AREA:
         case aiLightSource_UNDEFINED:
         case _aiLightSource_Force32Bit:
             break;
@@ -524,7 +523,7 @@ void ColladaExporter::ReadMaterialSurface( Surface& poSurface, const aiMaterial*
   } else
   {
     if( pKey )
-      poSurface.exist = pSrcMat->Get( pKey, pType, pIndex, poSurface.color) == aiReturn_SUCCESS;
+      poSurface.exist = pSrcMat->Get( pKey, static_cast<unsigned int>(pType), static_cast<unsigned int>(pIndex), poSurface.color) == aiReturn_SUCCESS;
   }
 }
 
@@ -651,7 +650,7 @@ void ColladaExporter::WriteMaterials()
       if( materialCountWithThisName == 0 ) {
         materials[a].name = name.C_Str();
       } else {
-        materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);  
+        materials[a].name = std::string(name.C_Str()) + to_string(materialCountWithThisName);
       }
     }
     for( std::string::iterator it = materials[a].name.begin(); it != materials[a].name.end(); ++it ) {
@@ -691,7 +690,7 @@ void ColladaExporter::WriteMaterials()
 
     materials[a].shininess.exist = mat->Get( AI_MATKEY_SHININESS, materials[a].shininess.value) == aiReturn_SUCCESS;
     materials[a].transparency.exist = mat->Get( AI_MATKEY_OPACITY, materials[a].transparency.value) == aiReturn_SUCCESS;
-    materials[a].transparency.value = 1 - materials[a].transparency.value;
+    materials[a].transparency.value = materials[a].transparency.value;
     materials[a].index_refraction.exist = mat->Get( AI_MATKEY_REFRACTI, materials[a].index_refraction.value) == aiReturn_SUCCESS;
   }
 
@@ -808,8 +807,8 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     const std::string idstr = GetMeshId( pIndex);
     const std::string idstrEscaped = XMLEscape(idstr);
 
-  if( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
-    return;
+    if ( mesh->mNumFaces == 0 || mesh->mNumVertices == 0 )
+        return;
 
     // opening tag
     mOutput << startstr << "<geometry id=\"" << idstrEscaped << "\" name=\"" << idstrEscaped << "_name\" >" << endstr;
@@ -827,7 +826,7 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     // texture coords
     for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
     {
-        if( mesh->HasTextureCoords( a) )
+        if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
         {
             WriteFloatArray( idstr + "-tex" + to_string(a), mesh->mNumUVComponents[a] == 3 ? FloatType_TexCoord3 : FloatType_TexCoord2,
                 (ai_real*) mesh->mTextureCoords[a], mesh->mNumVertices);
@@ -837,27 +836,15 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
     // vertex colors
     for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a)
     {
-        if( mesh->HasVertexColors( a) )
+        if( mesh->HasVertexColors(static_cast<unsigned int>(a)) )
             WriteFloatArray( idstr + "-color" + to_string(a), FloatType_Color, (ai_real*) mesh->mColors[a], mesh->mNumVertices);
     }
 
     // assemble vertex structure
+    // Only write input for POSITION since we will write other as shared inputs in polygon definition
     mOutput << startstr << "<vertices id=\"" << idstrEscaped << "-vertices" << "\">" << endstr;
     PushTag();
     mOutput << startstr << "<input semantic=\"POSITION\" source=\"#" << idstrEscaped << "-positions\" />" << endstr;
-    if( mesh->HasNormals() )
-        mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
-    for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
-    {
-        if( mesh->HasTextureCoords( a) )
-            mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " /*<< "set=\"" << a << "\"" */ << " />" << endstr;
-    }
-    for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
-    {
-        if( mesh->HasVertexColors( a) )
-            mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " /*<< set=\"" << a << "\"" */ << " />" << endstr;
-    }
-
     PopTag();
     mOutput << startstr << "</vertices>" << endstr;
 
@@ -876,6 +863,19 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
         mOutput << startstr << "<lines count=\"" << countLines << "\" material=\"defaultMaterial\">" << endstr;
         PushTag();
         mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstrEscaped << "-vertices\" />" << endstr;
+        if( mesh->HasNormals() )
+            mOutput << startstr << "<input semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
+        {
+            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
+                mOutput << startstr << "<input semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
+        {
+            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
+                mOutput << startstr << "<input semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+
         mOutput << startstr << "<p>";
         for( size_t a = 0; a < mesh->mNumFaces; ++a )
         {
@@ -897,10 +897,17 @@ void ColladaExporter::WriteGeometry( size_t pIndex)
         mOutput << startstr << "<polylist count=\"" << countPoly << "\" material=\"defaultMaterial\">" << endstr;
         PushTag();
         mOutput << startstr << "<input offset=\"0\" semantic=\"VERTEX\" source=\"#" << idstrEscaped << "-vertices\" />" << endstr;
+        if( mesh->HasNormals() )
+            mOutput << startstr << "<input offset=\"0\" semantic=\"NORMAL\" source=\"#" << idstrEscaped << "-normals\" />" << endstr;
         for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
         {
-            if( mesh->HasTextureCoords( a) )
-                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" set=\"" << a << "\" />" << endstr;
+            if( mesh->HasTextureCoords(static_cast<unsigned int>(a)) )
+                mOutput << startstr << "<input offset=\"0\" semantic=\"TEXCOORD\" source=\"#" << idstrEscaped << "-tex" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
+        }
+        for( size_t a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; ++a )
+        {
+            if( mesh->HasVertexColors(static_cast<unsigned int>(a) ) )
+                mOutput << startstr << "<input offset=\"0\" semantic=\"COLOR\" source=\"#" << idstrEscaped << "-color" << a << "\" " << "set=\"" << a << "\""  << " />" << endstr;
         }
 
         mOutput << startstr << "<vcount>";
@@ -1129,7 +1136,7 @@ void ColladaExporter::WriteNode( const aiScene* pScene, aiNode* pNode)
     PushTag();
     for( size_t a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++a )
     {
-        if( mesh->HasTextureCoords( a) )
+        if( mesh->HasTextureCoords( static_cast<unsigned int>(a) ) )
             // semantic       as in <texture texcoord=...>
             // input_semantic as in <input semantic=...>
             // input_set      as in <input set=...>

code/ColladaHelper.h

@@ -43,7 +43,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_COLLADAHELPER_H_INC
 #define AI_COLLADAHELPER_H_INC
 
-#include <string>
 #include <map>
 #include <vector>
 #include <stdint.h>
@@ -89,6 +88,21 @@ enum InputType
     IT_Bitangent
 };
 
+/** Supported controller types */
+enum ControllerType
+{
+    Skin,
+    Morph
+};
+
+/** Supported morph methods */
+enum MorphMethod
+{
+    Normalized,
+    Relative
+};
+
+
 /** Contains all data for one of the different transformation types */
 struct Transform
 {
@@ -380,6 +394,12 @@ enum PrimitiveType
 /** A skeleton controller to deform a mesh with the use of joints */
 struct Controller
 {
+    // controller type
+    ControllerType mType;
+
+    // Morphing method if type is Morph
+    MorphMethod mMethod;
+
     // the URL of the mesh deformed by the controller.
     std::string mMeshId;
 
@@ -402,6 +422,9 @@ struct Controller
 
     // JointIndex-WeightIndex pairs for all vertices
     std::vector< std::pair<size_t, size_t> > mWeights;
+
+    std::string mMorphTarget;
+    std::string mMorphWeight;
 };
 
 /** A collada material. Pretty much the only member is a reference to an effect. */
@@ -577,6 +600,12 @@ struct AnimationChannel
     std::string mSourceTimes;
     /** Source URL of the value values. Collada calls them "output". */
     std::string mSourceValues;
+    /** Source URL of the IN_TANGENT semantic values. */
+    std::string mInTanValues;
+    /** Source URL of the OUT_TANGENT semantic values. */
+    std::string mOutTanValues;
+    /** Source URL of the INTERPOLATION semantic values. */
+    std::string mInterpolationValues;
 };
 
 /** An animation. Container for 0-x animation channels or 0-x animations */
@@ -645,6 +674,7 @@ struct Animation
 struct ChannelEntry
 {
     const Collada::AnimationChannel* mChannel; ///> the source channel
+    std::string mTargetId;
     std::string mTransformId;   // the ID of the transformation step of the node which is influenced
     size_t mTransformIndex; // Index into the node's transform chain to apply the channel to
     size_t mSubElement; // starting index inside the transform data

code/ColladaLoader.cpp

@@ -49,18 +49,19 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/Importer.hpp>
-#include "ColladaParser.h"
+#include <assimp/importerdesc.h>
 
+#include "ColladaParser.h"
 #include "fast_atof.h"
 #include "ParsingUtils.h"
 #include "SkeletonMeshBuilder.h"
-#include "Defines.h"
+#include "CreateAnimMesh.h"
 
 #include "time.h"
 #include "math.h"
+#include <algorithm>
 #include <numeric>
-#include "Defines.h"
-
+#include <assimp/Defines.h>
 
 using namespace Assimp;
 using namespace Assimp::Formatter;
@@ -148,6 +149,7 @@ void ColladaLoader::InternReadFile( const std::string& pFile, aiScene* pScene, I
     mMeshIndexByID.clear();
     mMaterialIndexByName.clear();
     mMeshes.clear();
+    mTargetMeshes.clear();
     newMats.clear();
     mLights.clear();
     mCameras.clear();
@@ -240,7 +242,7 @@ aiNode* ColladaLoader::BuildHierarchy( const ColladaParser& pParser, const Colla
     ResolveNodeInstances(pParser,pNode,instances);
 
     // add children. first the *real* ones
-    node->mNumChildren = pNode->mChildren.size()+instances.size();
+    node->mNumChildren = static_cast<unsigned int>(pNode->mChildren.size()+instances.size());
     node->mChildren = new aiNode*[node->mNumChildren];
 
     for( size_t a = 0; a < pNode->mChildren.size(); a++)
@@ -506,7 +508,7 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
             std::map<std::string, size_t>::const_iterator matIt = mMaterialIndexByName.find( meshMaterial);
             unsigned int matIdx;
             if( matIt != mMaterialIndexByName.end())
-                matIdx = matIt->second;
+                matIdx = static_cast<unsigned int>(matIt->second);
             else
                 matIdx = 0;
 
@@ -553,14 +555,37 @@ void ColladaLoader::BuildMeshesForNode( const ColladaParser& pParser, const Coll
     }
 
     // now place all mesh references we gathered in the target node
-    pTarget->mNumMeshes = newMeshRefs.size();
+    pTarget->mNumMeshes = static_cast<unsigned int>(newMeshRefs.size());
     if( newMeshRefs.size())
     {
+        struct UIntTypeConverter
+        {
+            unsigned int operator()(const size_t& v) const
+            {
+                return static_cast<unsigned int>(v);
+            }
+        };
+
         pTarget->mMeshes = new unsigned int[pTarget->mNumMeshes];
-        std::copy( newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes);
+        std::transform( newMeshRefs.begin(), newMeshRefs.end(), pTarget->mMeshes, UIntTypeConverter());
     }
 }
 
+// ------------------------------------------------------------------------------------------------
+// Find mesh from either meshes or morph target meshes
+aiMesh *ColladaLoader::findMesh(std::string meshid)
+{
+    for (unsigned int i = 0; i < mMeshes.size(); i++)
+        if (std::string(mMeshes[i]->mName.data) == meshid)
+            return mMeshes[i];
+
+    for (unsigned int i = 0; i < mTargetMeshes.size(); i++)
+        if (std::string(mTargetMeshes[i]->mName.data) == meshid)
+            return mTargetMeshes[i];
+
+    return NULL;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh
 aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::Mesh* pSrcMesh, const Collada::SubMesh& pSubMesh,
@@ -572,10 +597,10 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
 
     // count the vertices addressed by its faces
     const size_t numVertices = std::accumulate( pSrcMesh->mFaceSize.begin() + pStartFace,
-        pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, 0);
+        pSrcMesh->mFaceSize.begin() + pStartFace + pSubMesh.mNumFaces, size_t(0));
 
     // copy positions
-    dstMesh->mNumVertices = numVertices;
+    dstMesh->mNumVertices = static_cast<unsigned int>(numVertices);
     dstMesh->mVertices = new aiVector3D[numVertices];
     std::copy( pSrcMesh->mPositions.begin() + pStartVertex, pSrcMesh->mPositions.begin() +
         pStartVertex + numVertices, dstMesh->mVertices);
@@ -634,20 +659,82 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
 
     // create faces. Due to the fact that each face uses unique vertices, we can simply count up on each vertex
     size_t vertex = 0;
-    dstMesh->mNumFaces = pSubMesh.mNumFaces;
+    dstMesh->mNumFaces = static_cast<unsigned int>(pSubMesh.mNumFaces);
     dstMesh->mFaces = new aiFace[dstMesh->mNumFaces];
     for( size_t a = 0; a < dstMesh->mNumFaces; ++a)
     {
         size_t s = pSrcMesh->mFaceSize[ pStartFace + a];
         aiFace& face = dstMesh->mFaces[a];
-        face.mNumIndices = s;
+        face.mNumIndices = static_cast<unsigned int>(s);
         face.mIndices = new unsigned int[s];
         for( size_t b = 0; b < s; ++b)
-            face.mIndices[b] = vertex++;
+            face.mIndices[b] = static_cast<unsigned int>(vertex++);
+    }
+
+    // create morph target meshes if any
+    std::vector<aiMesh*> targetMeshes;
+    std::vector<float> targetWeights;
+    Collada::MorphMethod method;
+
+    for(std::map<std::string, Collada::Controller>::const_iterator it = pParser.mControllerLibrary.begin();
+        it != pParser.mControllerLibrary.end(); it++)
+    {
+        const Collada::Controller &c = it->second;
+        const Collada::Mesh* baseMesh = pParser.ResolveLibraryReference( pParser.mMeshLibrary, c.mMeshId);
+
+        if (c.mType == Collada::Morph && baseMesh->mName == pSrcMesh->mName)
+        {
+            const Collada::Accessor& targetAccessor = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, c.mMorphTarget);
+            const Collada::Accessor& weightAccessor = pParser.ResolveLibraryReference( pParser.mAccessorLibrary, c.mMorphWeight);
+            const Collada::Data& targetData = pParser.ResolveLibraryReference( pParser.mDataLibrary, targetAccessor.mSource);
+            const Collada::Data& weightData = pParser.ResolveLibraryReference( pParser.mDataLibrary, weightAccessor.mSource);
+
+            // take method
+            method = c.mMethod;
+
+            if (!targetData.mIsStringArray)
+                throw DeadlyImportError( "target data must contain id. ");
+            if (weightData.mIsStringArray)
+                throw DeadlyImportError( "target weight data must not be textual ");
+
+            for (unsigned int i = 0; i < targetData.mStrings.size(); ++i)
+            {
+                const Collada::Mesh* targetMesh = pParser.ResolveLibraryReference(pParser.mMeshLibrary, targetData.mStrings.at(i));
+
+                aiMesh *aimesh = findMesh(targetMesh->mName);
+                if (!aimesh)
+                {
+                    if (targetMesh->mSubMeshes.size() > 1)
+                        throw DeadlyImportError( "Morhing target mesh must be a single");
+                    aimesh = CreateMesh(pParser, targetMesh, targetMesh->mSubMeshes.at(0), NULL, 0, 0);
+                    mTargetMeshes.push_back(aimesh);
+                }
+                targetMeshes.push_back(aimesh);
+            }
+            for (unsigned int i = 0; i < weightData.mValues.size(); ++i)
+                targetWeights.push_back(weightData.mValues.at(i));
+        }
+    }
+    if (targetMeshes.size() > 0 && targetWeights.size() == targetMeshes.size())
+    {
+        std::vector<aiAnimMesh*> animMeshes;
+        for (unsigned int i = 0; i < targetMeshes.size(); i++)
+        {
+            aiAnimMesh *animMesh = aiCreateAnimMesh(targetMeshes.at(i));
+            animMesh->mWeight = targetWeights[i];
+            animMeshes.push_back(animMesh);
+        }
+        dstMesh->mMethod = (method == Collada::Relative)
+                                ? aiMorphingMethod_MORPH_RELATIVE
+                                : aiMorphingMethod_MORPH_NORMALIZED;
+        dstMesh->mAnimMeshes = new aiAnimMesh*[animMeshes.size()];
+        dstMesh->mNumAnimMeshes = animMeshes.size();
+        for (unsigned int i = 0; i < animMeshes.size(); i++)
+            dstMesh->mAnimMeshes[i] = animMeshes.at(i);
     }
 
     // create bones if given
-    if( pSrcController)
+    if( pSrcController && pSrcController->mType == Collada::Skin)
     {
         // refuse if the vertex count does not match
 //      if( pSrcController->mWeightCounts.size() != dstMesh->mNumVertices)
@@ -710,7 +797,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
                 if( weight > 0.0f)
                 {
                     aiVertexWeight w;
-                    w.mVertexId = a - pStartVertex;
+                    w.mVertexId = static_cast<unsigned int>(a - pStartVertex);
                     w.mWeight = weight;
                     dstBones[jointIndex].push_back( w);
                 }
@@ -724,7 +811,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
                 numRemainingBones++;
 
         // create bone array and copy bone weights one by one
-        dstMesh->mNumBones = numRemainingBones;
+        dstMesh->mNumBones = static_cast<unsigned int>(numRemainingBones);
         dstMesh->mBones = new aiBone*[numRemainingBones];
         size_t boneCount = 0;
         for( size_t a = 0; a < numBones; ++a)
@@ -748,7 +835,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
             bone->mOffsetMatrix.c2 = ReadFloat( jointMatrixAcc, jointMatrices, a, 9);
             bone->mOffsetMatrix.c3 = ReadFloat( jointMatrixAcc, jointMatrices, a, 10);
             bone->mOffsetMatrix.c4 = ReadFloat( jointMatrixAcc, jointMatrices, a, 11);
-            bone->mNumWeights = dstBones[a].size();
+            bone->mNumWeights = static_cast<unsigned int>(dstBones[a].size());
             bone->mWeights = new aiVertexWeight[bone->mNumWeights];
             std::copy( dstBones[a].begin(), dstBones[a].end(), bone->mWeights);
 
@@ -798,7 +885,7 @@ aiMesh* ColladaLoader::CreateMesh( const ColladaParser& pParser, const Collada::
 // Stores all meshes in the given scene
 void ColladaLoader::StoreSceneMeshes( aiScene* pScene)
 {
-    pScene->mNumMeshes = mMeshes.size();
+    pScene->mNumMeshes = static_cast<unsigned int>(mMeshes.size());
     if( mMeshes.size() > 0)
     {
         pScene->mMeshes = new aiMesh*[mMeshes.size()];
@@ -811,7 +898,7 @@ void ColladaLoader::StoreSceneMeshes( aiScene* pScene)
 // Stores all cameras in the given scene
 void ColladaLoader::StoreSceneCameras( aiScene* pScene)
 {
-    pScene->mNumCameras = mCameras.size();
+    pScene->mNumCameras = static_cast<unsigned int>(mCameras.size());
     if( mCameras.size() > 0)
     {
         pScene->mCameras = new aiCamera*[mCameras.size()];
@@ -824,7 +911,7 @@ void ColladaLoader::StoreSceneCameras( aiScene* pScene)
 // Stores all lights in the given scene
 void ColladaLoader::StoreSceneLights( aiScene* pScene)
 {
-    pScene->mNumLights = mLights.size();
+    pScene->mNumLights = static_cast<unsigned int>(mLights.size());
     if( mLights.size() > 0)
     {
         pScene->mLights = new aiLight*[mLights.size()];
@@ -837,7 +924,7 @@ void ColladaLoader::StoreSceneLights( aiScene* pScene)
 // Stores all textures in the given scene
 void ColladaLoader::StoreSceneTextures( aiScene* pScene)
 {
-    pScene->mNumTextures = mTextures.size();
+    pScene->mNumTextures = static_cast<unsigned int>(mTextures.size());
     if( mTextures.size() > 0)
     {
         pScene->mTextures = new aiTexture*[mTextures.size()];
@@ -850,7 +937,7 @@ void ColladaLoader::StoreSceneTextures( aiScene* pScene)
 // Stores all materials in the given scene
 void ColladaLoader::StoreSceneMaterials( aiScene* pScene)
 {
-    pScene->mNumMaterials = newMats.size();
+    pScene->mNumMaterials = static_cast<unsigned int>(newMats.size());
 
     if (newMats.size() > 0) {
         pScene->mMaterials = new aiMaterial*[newMats.size()];
@@ -891,7 +978,7 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
                 combinedAnim->mName = aiString( std::string( "combinedAnim_") + char( '0' + a));
                 combinedAnim->mDuration = templateAnim->mDuration;
                 combinedAnim->mTicksPerSecond = templateAnim->mTicksPerSecond;
-                combinedAnim->mNumChannels = collectedAnimIndices.size() + 1;
+                combinedAnim->mNumChannels = static_cast<unsigned int>(collectedAnimIndices.size() + 1);
                 combinedAnim->mChannels = new aiNodeAnim*[combinedAnim->mNumChannels];
                 // add the template anim as first channel by moving its aiNodeAnim to the combined animation
                 combinedAnim->mChannels[0] = templateAnim->mChannels[0];
@@ -923,7 +1010,7 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
     // now store all anims in the scene
     if( !mAnims.empty())
     {
-        pScene->mNumAnimations = mAnims.size();
+        pScene->mNumAnimations = static_cast<unsigned int>(mAnims.size());
         pScene->mAnimations = new aiAnimation*[mAnims.size()];
         std::copy( mAnims.begin(), mAnims.end(), pScene->mAnimations);
     }
@@ -946,6 +1033,68 @@ void ColladaLoader::StoreAnimations( aiScene* pScene, const ColladaParser& pPars
         CreateAnimation( pScene, pParser, pSrcAnim, animName);
 }
 
+struct MorphTimeValues
+{
+    float mTime;
+    struct key
+    {
+        float mWeight;
+        unsigned int mValue;
+    };
+    std::vector<key> mKeys;
+};
+
+void insertMorphTimeValue(std::vector<MorphTimeValues> &values, float time, float weight, unsigned int value)
+{
+    MorphTimeValues::key k;
+    k.mValue = value;
+    k.mWeight = weight;
+    if (values.size() == 0 || time < values[0].mTime)
+    {
+        MorphTimeValues val;
+        val.mTime = time;
+        val.mKeys.push_back(k);
+        values.insert(values.begin(), val);
+        return;
+    }
+    if (time > values.back().mTime)
+    {
+        MorphTimeValues val;
+        val.mTime = time;
+        val.mKeys.push_back(k);
+        values.insert(values.end(), val);
+        return;
+    }
+    for (unsigned int i = 0; i < values.size(); i++)
+    {
+        if (std::abs(time - values[i].mTime) < 1e-6f)
+        {
+            values[i].mKeys.push_back(k);
+            return;
+        } else if (time > values[i].mTime && time < values[i+1].mTime)
+        {
+            MorphTimeValues val;
+            val.mTime = time;
+            val.mKeys.push_back(k);
+            values.insert(values.begin() + i, val);
+            return;
+        }
+    }
+    // should not get here
+}
+
+float getWeightAtKey(const std::vector<MorphTimeValues> &values, int key, unsigned int value)
+{
+    for (unsigned int i = 0; i < values[key].mKeys.size(); i++)
+    {
+        if (values[key].mKeys[i].mValue == value)
+            return values[key].mKeys[i].mWeight;
+    }
+    // no value at key found, try to interpolate if present at other keys. if not, return zero
+    // TODO: interpolation
+    return 0.0f;
+}
+
 // ------------------------------------------------------------------------------------------------
 // Constructs the animation for the given source anim
 void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pParser, const Collada::Animation* pSrcAnim, const std::string& pName)
@@ -955,6 +1104,8 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
     CollectNodes( pScene->mRootNode, nodes);
 
     std::vector<aiNodeAnim*> anims;
+    std::vector<aiMeshMorphAnim*> morphAnims;
+
     for( std::vector<const aiNode*>::const_iterator nit = nodes.begin(); nit != nodes.end(); ++nit)
     {
         // find all the collada anim channels which refer to the current node
@@ -978,7 +1129,20 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
             // find the slash that separates the node name - there should be only one
             std::string::size_type slashPos = srcChannel.mTarget.find( '/');
             if( slashPos == std::string::npos)
+            {
+                std::string::size_type targetPos = srcChannel.mTarget.find(srcNode->mID);
+                if (targetPos == std::string::npos)
+                    continue;
+
+                // not node transform, but something else. store as unknown animation channel for now
+                entry.mChannel = &(*cit);
+                entry.mTargetId = srcChannel.mTarget.substr(targetPos + pSrcAnim->mName.length(),
+                                        srcChannel.mTarget.length() - targetPos - pSrcAnim->mName.length());
+                if (entry.mTargetId.front() == '-')
+                    entry.mTargetId = entry.mTargetId.substr(1);
+                entries.push_back(entry);
                 continue;
+            }
             if( srcChannel.mTarget.find( '/', slashPos+1) != std::string::npos)
                 continue;
             std::string targetID = srcChannel.mTarget.substr( 0, slashPos);
@@ -1058,8 +1222,14 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
                 if( srcNode->mTransforms[a].mID == entry.mTransformId)
                     entry.mTransformIndex = a;
 
-            if( entry.mTransformIndex == SIZE_MAX) {
-                continue;
+            if( entry.mTransformIndex == SIZE_MAX)
+            {
+                if (entry.mTransformId.find("morph-weights") != std::string::npos)
+                {
+                    entry.mTargetId = entry.mTransformId;
+                    entry.mTransformId = "";
+                } else
+                    continue;
             }
 
             entry.mChannel = &(*cit);
@@ -1203,49 +1373,125 @@ void ColladaLoader::CreateAnimation( aiScene* pScene, const ColladaParser& pPars
 //      ai_assert( resultTrafos.size() > 0);
 
         // build an animation channel for the given node out of these trafo keys
-    if( !resultTrafos.empty() )
-    {
-          aiNodeAnim* dstAnim = new aiNodeAnim;
-          dstAnim->mNodeName = nodeName;
-          dstAnim->mNumPositionKeys = resultTrafos.size();
-          dstAnim->mNumRotationKeys= resultTrafos.size();
-          dstAnim->mNumScalingKeys = resultTrafos.size();
-          dstAnim->mPositionKeys = new aiVectorKey[resultTrafos.size()];
-          dstAnim->mRotationKeys = new aiQuatKey[resultTrafos.size()];
-          dstAnim->mScalingKeys = new aiVectorKey[resultTrafos.size()];
-
-          for( size_t a = 0; a < resultTrafos.size(); ++a)
-          {
-              aiMatrix4x4 mat = resultTrafos[a];
-              double time = double( mat.d4); // remember? time is stored in mat.d4
-        mat.d4 = 1.0f;
-
-              dstAnim->mPositionKeys[a].mTime = time;
-              dstAnim->mRotationKeys[a].mTime = time;
-              dstAnim->mScalingKeys[a].mTime = time;
-              mat.Decompose( dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue);
-          }
+        if( !resultTrafos.empty() )
+        {
+              aiNodeAnim* dstAnim = new aiNodeAnim;
+              dstAnim->mNodeName = nodeName;
+              dstAnim->mNumPositionKeys = resultTrafos.size();
+              dstAnim->mNumRotationKeys= resultTrafos.size();
+              dstAnim->mNumScalingKeys = resultTrafos.size();
+              dstAnim->mPositionKeys = new aiVectorKey[resultTrafos.size()];
+              dstAnim->mRotationKeys = new aiQuatKey[resultTrafos.size()];
+              dstAnim->mScalingKeys = new aiVectorKey[resultTrafos.size()];
+
+              for( size_t a = 0; a < resultTrafos.size(); ++a)
+              {
+                  aiMatrix4x4 mat = resultTrafos[a];
+                  double time = double( mat.d4); // remember? time is stored in mat.d4
+                    mat.d4 = 1.0f;
+
+                  dstAnim->mPositionKeys[a].mTime = time;
+                  dstAnim->mRotationKeys[a].mTime = time;
+                  dstAnim->mScalingKeys[a].mTime = time;
+                  mat.Decompose( dstAnim->mScalingKeys[a].mValue, dstAnim->mRotationKeys[a].mValue, dstAnim->mPositionKeys[a].mValue);
+              }
 
-          anims.push_back( dstAnim);
-    } else
-    {
-      DefaultLogger::get()->warn( "Collada loader: found empty animation channel, ignored. Please check your exporter.");
-    }
+              anims.push_back( dstAnim);
+        } else
+        {
+          DefaultLogger::get()->warn( "Collada loader: found empty animation channel, ignored. Please check your exporter.");
+        }
+
+        if( !entries.empty() && entries.front().mTimeAccessor->mCount > 0 )
+        {
+            std::vector<Collada::ChannelEntry> morphChannels;
+            for( std::vector<Collada::ChannelEntry>::iterator it = entries.begin(); it != entries.end(); ++it)
+            {
+                Collada::ChannelEntry& e = *it;
+
+                // skip non-transform types
+                if (e.mTargetId.empty())
+                    continue;
+
+                if (e.mTargetId.find("morph-weights") != std::string::npos)
+                    morphChannels.push_back(e);
+            }
+            if (morphChannels.size() > 0)
+            {
+                // either 1) morph weight animation count should contain morph target count channels
+                // or     2) one channel with morph target count arrays
+                // assume first
+
+                aiMeshMorphAnim *morphAnim = new aiMeshMorphAnim;
+                morphAnim->mName.Set(nodeName);
+
+                std::vector<MorphTimeValues> morphTimeValues;
+
+                int morphAnimChannelIndex = 0;
+                for( std::vector<Collada::ChannelEntry>::iterator it = morphChannels.begin(); it != morphChannels.end(); ++it)
+                {
+                    Collada::ChannelEntry& e = *it;
+                    std::string::size_type apos = e.mTargetId.find('(');
+                    std::string::size_type bpos = e.mTargetId.find(')');
+                    if (apos == std::string::npos || bpos == std::string::npos)
+                        // unknown way to specify weight -> ignore this animation
+                        continue;
+
+                    // weight target can be in format Weight_M_N, Weight_N, WeightN, or some other way
+                    // we ignore the name and just assume the channels are in the right order
+                    for (unsigned int i = 0; i < e.mTimeData->mValues.size(); i++)
+                        insertMorphTimeValue(morphTimeValues, e.mTimeData->mValues.at(i), e.mValueData->mValues.at(i), morphAnimChannelIndex);
+
+                    ++morphAnimChannelIndex;
+                }
+
+                morphAnim->mNumKeys = morphTimeValues.size();
+                morphAnim->mKeys = new aiMeshMorphKey[morphAnim->mNumKeys];
+                for (unsigned int key = 0; key < morphAnim->mNumKeys; key++)
+                {
+                    morphAnim->mKeys[key].mNumValuesAndWeights = morphChannels.size();
+                    morphAnim->mKeys[key].mValues = new unsigned int [morphChannels.size()];
+                    morphAnim->mKeys[key].mWeights = new double [morphChannels.size()];
+
+                    morphAnim->mKeys[key].mTime = morphTimeValues[key].mTime;
+                    for (unsigned int valueIndex = 0; valueIndex < morphChannels.size(); valueIndex++)
+                    {
+                        morphAnim->mKeys[key].mValues[valueIndex] = valueIndex;
+                        morphAnim->mKeys[key].mWeights[valueIndex] = getWeightAtKey(morphTimeValues, key, valueIndex);
+                    }
+                }
+
+                morphAnims.push_back(morphAnim);
+            }
+        }
     }
 
-    if( !anims.empty())
+    if( !anims.empty() || !morphAnims.empty())
     {
         aiAnimation* anim = new aiAnimation;
         anim->mName.Set( pName);
         anim->mNumChannels = anims.size();
-        anim->mChannels = new aiNodeAnim*[anims.size()];
-        std::copy( anims.begin(), anims.end(), anim->mChannels);
+        if (anim->mNumChannels > 0)
+        {
+            anim->mChannels = new aiNodeAnim*[anims.size()];
+            std::copy( anims.begin(), anims.end(), anim->mChannels);
+        }
+        anim->mNumMorphMeshChannels = morphAnims.size();
+        if (anim->mNumMorphMeshChannels > 0)
+        {
+            anim->mMorphMeshChannels = new aiMeshMorphAnim*[anim->mNumMorphMeshChannels];
+            std::copy( morphAnims.begin(), morphAnims.end(), anim->mMorphMeshChannels);
+        }
         anim->mDuration = 0.0f;
         for( size_t a = 0; a < anims.size(); ++a)
         {
-            anim->mDuration = std::max( anim->mDuration, anims[a]->mPositionKeys[anims[a]->mNumPositionKeys-1].mTime);
-            anim->mDuration = std::max( anim->mDuration, anims[a]->mRotationKeys[anims[a]->mNumRotationKeys-1].mTime);
-            anim->mDuration = std::max( anim->mDuration, anims[a]->mScalingKeys[anims[a]->mNumScalingKeys-1].mTime);
+                anim->mDuration = std::max( anim->mDuration, anims[a]->mPositionKeys[anims[a]->mNumPositionKeys-1].mTime);
+                anim->mDuration = std::max( anim->mDuration, anims[a]->mRotationKeys[anims[a]->mNumRotationKeys-1].mTime);
+                anim->mDuration = std::max( anim->mDuration, anims[a]->mScalingKeys[anims[a]->mNumScalingKeys-1].mTime);
+        }
+        for (size_t a = 0; a < morphAnims.size(); ++a)
+        {
+            anim->mDuration = std::max(anim->mDuration, morphAnims[a]->mKeys[morphAnims[a]->mNumKeys-1].mTime);
         }
         anim->mTicksPerSecond = 1;
         mAnims.push_back( anim);
@@ -1520,13 +1766,13 @@ aiString ColladaLoader::FindFilenameForEffectTexture( const ColladaParser& pPars
 
         // and copy texture data
         tex->mHeight = 0;
-        tex->mWidth = imIt->second.mImageData.size();
+        tex->mWidth = static_cast<unsigned int>(imIt->second.mImageData.size());
         tex->pcData = (aiTexel*)new char[tex->mWidth];
         memcpy(tex->pcData,&imIt->second.mImageData[0],tex->mWidth);
 
         // setup texture reference string
         result.data[0] = '*';
-        result.length = 1 + ASSIMP_itoa10(result.data+1,MAXLEN-1,mTextures.size());
+        result.length = 1 + ASSIMP_itoa10(result.data+1,static_cast<unsigned int>(MAXLEN-1),static_cast<int32_t>(mTextures.size()));
 
         // and add this texture to the list
         mTextures.push_back(tex);

code/ColladaLoader.h

@@ -117,6 +117,8 @@ protected:
     /** Builds meshes for the given node and references them */
     void BuildMeshesForNode( const ColladaParser& pParser, const Collada::Node* pNode,
         aiNode* pTarget);
+		
+    aiMesh *findMesh(std::string meshid);
 
     /** Creates a mesh for the given ColladaMesh face subset and returns the newly created mesh */
     aiMesh* CreateMesh( const ColladaParser& pParser, const Collada::Mesh* pSrcMesh, const Collada::SubMesh& pSubMesh,
@@ -223,6 +225,9 @@ protected:
 
     /** Accumulated meshes for the target scene */
     std::vector<aiMesh*> mMeshes;
+	
+    /** Accumulated morph target meshes */
+    std::vector<aiMesh*> mTargetMeshes;
 
     /** Temporary material list */
     std::vector<std::pair<Collada::Effect*, aiMaterial*> > newMats;

code/ColladaParser.cpp

@@ -59,7 +59,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <memory>
 
-
 using namespace Assimp;
 using namespace Assimp::Collada;
 using namespace Assimp::Formatter;
@@ -586,6 +585,12 @@ void ColladaParser::ReadAnimationSampler( Collada::AnimationChannel& pChannel)
                     pChannel.mSourceTimes = source;
                 else if( strcmp( semantic, "OUTPUT") == 0)
                     pChannel.mSourceValues = source;
+                else if( strcmp( semantic, "IN_TANGENT") == 0)
+                    pChannel.mInTanValues = source;
+                else if( strcmp( semantic, "OUT_TANGENT") == 0)
+                    pChannel.mOutTanValues = source;
+                else if( strcmp( semantic, "INTERPOLATION") == 0)
+                    pChannel.mInterpolationValues = source;
 
                 if( !mReader->isEmptyElement())
                     SkipElement();
@@ -648,6 +653,9 @@ void ColladaParser::ReadControllerLibrary()
 // Reads a controller into the given mesh structure
 void ColladaParser::ReadController( Collada::Controller& pController)
 {
+    // initial values
+    pController.mType = Skin;
+    pController.mMethod = Normalized;
     while( mReader->read())
     {
         if( mReader->getNodeType() == irr::io::EXN_ELEMENT)
@@ -655,8 +663,15 @@ void ColladaParser::ReadController( Collada::Controller& pController)
             // two types of controllers: "skin" and "morph". Only the first one is relevant, we skip the other
             if( IsElement( "morph"))
             {
-                // should skip everything inside, so there's no danger of catching elements inbetween
-                SkipElement();
+                pController.mType = Morph;
+                int baseIndex = GetAttribute("source");
+                pController.mMeshId = mReader->getAttributeValue(baseIndex) + 1;
+                int methodIndex = GetAttribute("method");
+                if (methodIndex > 0) {
+                    const char *method = mReader->getAttributeValue(methodIndex);
+                    if (strcmp(method, "RELATIVE") == 0)
+                        pController.mMethod = Relative;
+                }
             }
             else if( IsElement( "skin"))
             {
@@ -668,18 +683,18 @@ void ColladaParser::ReadController( Collada::Controller& pController)
             else if( IsElement( "bind_shape_matrix"))
             {
                 // content is 16 floats to define a matrix... it seems to be important for some models
-          const char* content = GetTextContent();
+                const char* content = GetTextContent();
 
-          // read the 16 floats
-          for( unsigned int a = 0; a < 16; a++)
-          {
-              // read a number
-          content = fast_atoreal_move<ai_real>( content, pController.mBindShapeMatrix[a]);
-              // skip whitespace after it
-              SkipSpacesAndLineEnd( &content);
-          }
+                // read the 16 floats
+                for( unsigned int a = 0; a < 16; a++)
+                {
+                    // read a number
+                    content = fast_atoreal_move<ai_real>( content, pController.mBindShapeMatrix[a]);
+                    // skip whitespace after it
+                    SkipSpacesAndLineEnd( &content);
+                }
 
-        TestClosing( "bind_shape_matrix");
+                TestClosing( "bind_shape_matrix");
             }
             else if( IsElement( "source"))
             {
@@ -694,6 +709,32 @@ void ColladaParser::ReadController( Collada::Controller& pController)
             {
                 ReadControllerWeights( pController);
             }
+            else if ( IsElement( "targets" ))
+            {
+                while (mReader->read()) {
+                    if( mReader->getNodeType() == irr::io::EXN_ELEMENT) {
+                        if ( IsElement( "input")) {
+                            int semanticsIndex = GetAttribute("semantic");
+                            int sourceIndex = GetAttribute("source");
+
+                            const char *semantics = mReader->getAttributeValue(semanticsIndex);
+                            const char *source = mReader->getAttributeValue(sourceIndex);
+                            if (strcmp(semantics, "MORPH_TARGET") == 0) {
+                                pController.mMorphTarget = source + 1;
+                            }
+                            else if (strcmp(semantics, "MORPH_WEIGHT") == 0)
+                            {
+                                pController.mMorphWeight = source + 1;
+                            }
+                        }
+                    } else if( mReader->getNodeType() == irr::io::EXN_ELEMENT_END) {
+                        if( strcmp( mReader->getNodeName(), "targets") == 0)
+                            break;
+                        else
+                            ThrowException( "Expected end of <targets> element.");
+                    }
+                }
+            }
             else
             {
                 // ignore the rest
@@ -704,7 +745,7 @@ void ColladaParser::ReadController( Collada::Controller& pController)
         {
             if( strcmp( mReader->getNodeName(), "controller") == 0)
                 break;
-            else if( strcmp( mReader->getNodeName(), "skin") != 0)
+            else if( strcmp( mReader->getNodeName(), "skin") != 0 && strcmp( mReader->getNodeName(), "morph") != 0)
                 ThrowException( "Expected end of <controller> element.");
         }
     }
@@ -1593,7 +1634,7 @@ void ColladaParser::ReadEffectColor( aiColor4D& pColor, Sampler& pSampler)
             }
             else if( IsElement( "texture"))
             {
-                // get name of source textur/sampler
+                // get name of source texture/sampler
                 int attrTex = GetAttribute( "texture");
                 pSampler.mName = mReader->getAttributeValue( attrTex);
 
@@ -2312,9 +2353,9 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
 		ThrowException( "Expected different index count in <p> element.");
 
 	// find the data for all sources
-  for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
+    for( std::vector<InputChannel>::iterator it = pMesh->mPerVertexData.begin(); it != pMesh->mPerVertexData.end(); ++it)
     {
-    InputChannel& input = *it;
+        InputChannel& input = *it;
         if( input.mResolved)
             continue;
 
@@ -2326,9 +2367,9 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
             acc->mData = &ResolveLibraryReference( mDataLibrary, acc->mSource);
     }
     // and the same for the per-index channels
-  for( std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
-  {
-    InputChannel& input = *it;
+    for( std::vector<InputChannel>::iterator it = pPerIndexChannels.begin(); it != pPerIndexChannels.end(); ++it)
+    {
+        InputChannel& input = *it;
         if( input.mResolved)
             continue;
 
@@ -2410,6 +2451,9 @@ size_t ColladaParser::ReadPrimitives( Mesh* pMesh, std::vector<InputChannel>& pP
     return numPrimitives;
 }
 
+///@note This function willn't work correctly if both PerIndex and PerVertex channels have same channels.
+///For example if TEXCOORD present in both <vertices> and <polylist> tags this function will create wrong uv coordinates.
+///It's not clear from COLLADA documentation is this allowed or not. For now only exporter fixed to avoid such behavior
 void ColladaParser::CopyVertex(size_t currentVertex, size_t numOffsets, size_t numPoints, size_t perVertexOffset, Mesh* pMesh, std::vector<InputChannel>& pPerIndexChannels, size_t currentPrimitive, const std::vector<size_t>& indices){
     // calculate the base offset of the vertex whose attributes we ant to copy
     size_t baseOffset = currentPrimitive * numOffsets * numPoints + currentVertex * numOffsets;
@@ -2535,7 +2579,7 @@ void ColladaParser::ExtractDataObjectFromChannel( const InputChannel& pInput, si
                 aiColor4D result(0, 0, 0, 1);
                 for (size_t i = 0; i < pInput.mResolved->mSize; ++i)
                 {
-                    result[i] = obj[pInput.mResolved->mSubOffset[i]];
+                    result[static_cast<unsigned int>(i)] = obj[pInput.mResolved->mSubOffset[i]];
                 }
                 pMesh->mColors[pInput.mIndex].push_back(result);
             } else
@@ -2828,7 +2872,7 @@ void ColladaParser::ReadNodeGeometry( Node* pNode)
 
     if( !mReader->isEmptyElement())
     {
-        // read material associations. Ignore additional elements inbetween
+        // read material associations. Ignore additional elements in between
         while( mReader->read())
         {
             if( mReader->getNodeType() == irr::io::EXN_ELEMENT)

code/ColladaParser.h

@@ -49,7 +49,6 @@
 #include "ColladaHelper.h"
 #include <assimp/ai_assert.h>
 #include "TinyFormatter.h"
-#include <memory>
 
 namespace Assimp
 {
@@ -268,8 +267,7 @@ namespace Assimp
         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;
+        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 */

code/CreateAnimMesh.cpp

@@ -0,0 +1,92 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (C) 2016 The Qt Company Ltd.
+Copyright (c) 2006-2012, 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 "CreateAnimMesh.h"
+
+namespace Assimp    {
+
+aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh)
+{
+    aiAnimMesh *animesh = new aiAnimMesh;
+    animesh->mVertices = NULL;
+    animesh->mNormals = NULL;
+    animesh->mTangents = NULL;
+    animesh->mBitangents = NULL;
+    animesh->mNumVertices = mesh->mNumVertices;
+    if (mesh->mVertices) {
+        animesh->mVertices = new aiVector3D[animesh->mNumVertices];
+        std::memcpy(animesh->mVertices, mesh->mVertices, mesh->mNumVertices * sizeof(aiVector3D));
+    }
+    if (mesh->mNormals) {
+        animesh->mNormals = new aiVector3D[animesh->mNumVertices];
+        std::memcpy(animesh->mNormals, mesh->mNormals, mesh->mNumVertices * sizeof(aiVector3D));
+    }
+    if (mesh->mTangents) {
+        animesh->mTangents = new aiVector3D[animesh->mNumVertices];
+        std::memcpy(animesh->mTangents, mesh->mTangents, mesh->mNumVertices * sizeof(aiVector3D));
+    }
+    if (mesh->mBitangents) {
+        animesh->mBitangents = new aiVector3D[animesh->mNumVertices];
+        std::memcpy(animesh->mBitangents, mesh->mBitangents, mesh->mNumVertices * sizeof(aiVector3D));
+    }
+
+    for (int i = 0; i < AI_MAX_NUMBER_OF_COLOR_SETS; ++i) {
+        if (mesh->mColors[i]) {
+            animesh->mColors[i] = new aiColor4D[animesh->mNumVertices];
+            std::memcpy(animesh->mColors[i], mesh->mColors[i], mesh->mNumVertices * sizeof(aiColor4D));
+        } else {
+            animesh->mColors[i] = NULL;
+        }
+    }
+
+    for (int i = 0; i < AI_MAX_NUMBER_OF_TEXTURECOORDS; ++i) {
+        if (mesh->mTextureCoords[i]) {
+            animesh->mTextureCoords[i] = new aiVector3D[animesh->mNumVertices];
+            std::memcpy(animesh->mTextureCoords[i], mesh->mTextureCoords[i], mesh->mNumVertices * sizeof(aiVector3D));
+        } else {
+            animesh->mTextureCoords[i] = NULL;
+        }
+    }
+    return animesh;
+}
+
+} // end of namespace Assimp

code/CreateAnimMesh.h

@@ -0,0 +1,56 @@
+/*
+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 CreateAnimMesh.h
+ *  Create AnimMesh from Mesh
+ */
+#ifndef INCLUDED_AI_CREATE_ANIM_MESH_H
+#define INCLUDED_AI_CREATE_ANIM_MESH_H
+
+#include <assimp/mesh.h>
+
+namespace Assimp    {
+
+/** Create aiAnimMesh from aiMesh. */
+aiAnimMesh *aiCreateAnimMesh(const aiMesh *mesh);
+
+} // end of namespace Assimp
+#endif // INCLUDED_AI_CREATE_ANIM_MESH_H
+

code/D3MFImporter.cpp

@@ -38,29 +38,23 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
+
 #include "D3MFImporter.h"
 
 #include <assimp/scene.h>
-#include <assimp/IOStream.hpp>
 #include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
+#include <assimp/importerdesc.h>
 #include "StringComparison.h"
 #include "StringUtils.h"
 
-
 #include <string>
-#include <sstream>
 #include <vector>
 #include <map>
-#include <algorithm>
 #include <cassert>
-#include <cstdlib>
 #include <memory>
 
-#include <assimp/ai_assert.h>
-
-#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
-
 #include "D3MFOpcPackage.h"
 #include <contrib/unzip/unzip.h>
 #include "irrXMLWrapper.h"
@@ -68,7 +62,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 namespace Assimp {
 namespace D3MF {
 
-
 namespace XmlTag {
     static const std::string model     = "model";
     static const std::string metadata  = "metadata";
@@ -104,31 +97,21 @@ public:
 
     }
 
-    void ImportXml(aiScene* scene)
-    {
-
-        scene->mFlags |= AI_SCENE_FLAGS_NON_VERBOSE_FORMAT;
-
+    void ImportXml(aiScene* scene) {
         scene->mRootNode = new aiNode();
         std::vector<aiNode*> children;
 
-        while(ReadToEndElement(D3MF::XmlTag::model))
-        {
-
-            if(xmlReader->getNodeName() == D3MF::XmlTag::object)
-            {
+        while(ReadToEndElement(D3MF::XmlTag::model)) {
+            if(xmlReader->getNodeName() == D3MF::XmlTag::object) {
                 children.push_back(ReadObject(scene));
-            }
-            else if(xmlReader->getNodeName() == D3MF::XmlTag::build)
-            {
-
+            } 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]();
 
@@ -172,7 +155,7 @@ private:
 
                 mesh->mName.Set(name);
                 meshes.push_back(mesh);
-                meshIds.push_back(meshIdx);
+                meshIds.push_back(static_cast<unsigned long>(meshIdx));
                 meshIdx++;
 
             }
@@ -229,9 +212,10 @@ private:
     aiVector3D ReadVertex()
     {
         aiVector3D vertex;
+
         vertex.x = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::x.c_str()), nullptr);
         vertex.y = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::y.c_str()), nullptr);
-        vertex.z = ai_strtof>(xmlReader->getAttributeValue(D3MF::XmlTag::z.c_str()), nullptr);
+        vertex.z = ai_strtof(xmlReader->getAttributeValue(D3MF::XmlTag::z.c_str()), nullptr);
 
         return vertex;
     }
@@ -312,8 +296,6 @@ private:
 private:
     std::vector<aiMesh*> meshes;
     XmlReader* xmlReader;
-
-
 };
 
 } //namespace D3MF

code/D3MFImporter.h

@@ -41,9 +41,6 @@ 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 {

code/D3MFOpcPackage.cpp

@@ -38,6 +38,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 ----------------------------------------------------------------------
 */
 
+#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
 
 #include "D3MFOpcPackage.h"
 #include "Exceptional.h"
@@ -52,9 +53,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <map>
 #include <algorithm>
 #include <cassert>
-#include <cstdlib>
-
-#ifndef ASSIMP_BUILD_NO_3MF_IMPORTER
 
 #include <contrib/unzip/unzip.h>
 
@@ -123,19 +121,19 @@ voidpf IOSystem2Unzip::open(voidpf opaque, const char* filename, int mode) {
 uLong IOSystem2Unzip::read(voidpf /*opaque*/, voidpf stream, void* buf, uLong size) {
     IOStream* io_stream = (IOStream*) stream;
 
-    return io_stream->Read(buf, 1, size);
+    return static_cast<uLong>(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);
+    return static_cast<uLong>(io_stream->Write(buf, 1, size));
 }
 
 long IOSystem2Unzip::tell(voidpf /*opaque*/, voidpf stream) {
     IOStream* io_stream = (IOStream*) stream;
 
-    return io_stream->Tell();
+    return static_cast<long>(io_stream->Tell());
 }
 
 long IOSystem2Unzip::seek(voidpf /*opaque*/, voidpf stream, uLong offset, int origin) {

code/D3MFOpcPackage.h

@@ -41,7 +41,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef D3MFOPCPACKAGE_H
 #define D3MFOPCPACKAGE_H
 
-#include <string>
 #include <memory>
 
 #include <assimp/IOSystem.hpp>

code/DXFLoader.cpp

@@ -54,6 +54,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "DXFHelper.h"
 #include <assimp/IOSystem.hpp>
 #include <assimp/scene.h>
+#include <assimp/importerdesc.h>
+
 #include <numeric>
 
 using namespace Assimp;
@@ -223,8 +225,8 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
         unsigned int vcount = 0, icount = 0;
         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();
+                vcount += static_cast<unsigned int>(pl->positions.size());
+                icount += static_cast<unsigned int>(pl->counts.size());
             }
         }
 
@@ -296,7 +298,7 @@ void DXFImporter::ConvertMeshes(aiScene* pScene, DXF::FileData& output)
         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();
+            cface += static_cast<unsigned int>(pl->counts.size());
         }
 
         aiVector3D* verts = mesh->mVertices = new aiVector3D[cvert];
@@ -705,7 +707,7 @@ void DXFImporter::ParsePolyLine(DXF::LineReader& reader, DXF::FileData& output)
 
         // closed polyline?
         if (line.flags & DXF_POLYLINE_FLAG_CLOSED) {
-            line.indices.push_back(line.positions.size()-1);
+            line.indices.push_back(static_cast<unsigned int>(line.positions.size()-1));
             line.indices.push_back(0);
             line.counts.push_back(2);
         }
@@ -906,7 +908,7 @@ void DXFImporter::Parse3DFace(DXF::LineReader& reader, DXF::FileData& output)
     line.counts.push_back(cnt);
 
     for (unsigned int i = 0; i < cnt; ++i) {
-        line.indices.push_back(line.positions.size());
+        line.indices.push_back(static_cast<unsigned int>(line.positions.size()));
         line.positions.push_back(vip[i]);
         line.colors.push_back(clr);
     }

code/DXFLoader.h

@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define AI_DXFLOADER_H_INCLUDED
 
 #include "BaseImporter.h"
+#include <map>
 
 namespace Assimp    {
     namespace DXF {

code/DeboneProcess.cpp

@@ -137,7 +137,7 @@ void DeboneProcess::Execute( aiScene* pScene)
                     const aiString *find = newMeshes[b].second?&newMeshes[b].second->mName:0;
 
                     aiNode *theNode = find?pScene->mRootNode->FindNode(*find):0;
-                    std::pair<unsigned int,aiNode*> push_pair(meshes.size(),theNode);
+                    std::pair<unsigned int,aiNode*> push_pair(static_cast<unsigned int>(meshes.size()),theNode);
 
                     mSubMeshIndices[a].push_back(push_pair);
                     meshes.push_back(newMeshes[b].first);
@@ -156,13 +156,13 @@ void DeboneProcess::Execute( aiScene* pScene)
             }
             else    {
                 // Mesh is kept unchanged - store it's new place in the mesh array
-                mSubMeshIndices[a].push_back(std::pair<unsigned int,aiNode*>(meshes.size(),(aiNode*)0));
+                mSubMeshIndices[a].push_back(std::pair<unsigned int,aiNode*>(static_cast<unsigned int>(meshes.size()),(aiNode*)0));
                 meshes.push_back(srcMesh);
             }
         }
 
         // rebuild the scene's mesh array
-        pScene->mNumMeshes = meshes.size();
+        pScene->mNumMeshes = static_cast<unsigned int>(meshes.size());
         delete [] pScene->mMeshes;
         pScene->mMeshes = new aiMesh*[pScene->mNumMeshes];
         std::copy( meshes.begin(), meshes.end(), pScene->mMeshes);
@@ -382,7 +382,7 @@ void DeboneProcess::UpdateNode(aiNode* pNode) const
 
     // this will require two passes
 
-    unsigned int m = pNode->mNumMeshes, n = mSubMeshIndices.size();
+    unsigned int m = static_cast<unsigned int>(pNode->mNumMeshes), n = static_cast<unsigned int>(mSubMeshIndices.size());
 
     // first pass, look for meshes which have not moved
 
@@ -390,7 +390,7 @@ void DeboneProcess::UpdateNode(aiNode* pNode) const
 
         unsigned int srcIndex = pNode->mMeshes[a];
         const std::vector< std::pair< unsigned int,aiNode* > > &subMeshes = mSubMeshIndices[srcIndex];
-        unsigned int nSubmeshes = subMeshes.size();
+        unsigned int nSubmeshes = static_cast<unsigned int>(subMeshes.size());
 
         for(unsigned int b=0;b<nSubmeshes;b++) {
             if(!subMeshes[b].second) {
@@ -404,7 +404,7 @@ void DeboneProcess::UpdateNode(aiNode* pNode) const
     for(unsigned int a=0;a<n;a++)
     {
         const std::vector< std::pair< unsigned int,aiNode* > > &subMeshes = mSubMeshIndices[a];
-        unsigned int nSubmeshes = subMeshes.size();
+        unsigned int nSubmeshes = static_cast<unsigned int>(subMeshes.size());
 
         for(unsigned int b=0;b<nSubmeshes;b++) {
             if(subMeshes[b].second == pNode)    {
@@ -417,7 +417,7 @@ void DeboneProcess::UpdateNode(aiNode* pNode) const
         delete [] pNode->mMeshes; pNode->mMeshes = NULL;
     }
 
-    pNode->mNumMeshes = newMeshList.size();
+    pNode->mNumMeshes = static_cast<unsigned int>(newMeshList.size());
 
     if(pNode->mNumMeshes)   {
         pNode->mMeshes = new unsigned int[pNode->mNumMeshes];

code/DefaultIOStream.cpp

@@ -44,7 +44,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 
 #include <assimp/ai_assert.h>
-#include "DefaultIOStream.h"
+#include <assimp/DefaultIOStream.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 
@@ -120,13 +120,13 @@ size_t DefaultIOStream::FileSize() const
         //
         // See here for details:
         // https://www.securecoding.cert.org/confluence/display/seccode/FIO19-C.+Do+not+use+fseek()+and+ftell()+to+compute+the+size+of+a+regular+file
-#if defined _WIN32
+#if defined _WIN32 && (!defined __GNUC__ || __MSVCRT_VERSION__ >= 0x0601)
         struct __stat64 fileStat;
         int err = _stat64(  mFilename.c_str(), &fileStat );
         if (0 != err)
             return 0;
         mCachedSize = (size_t) (fileStat.st_size);
-#elif defined __gnu_linux__ || defined __APPLE__ || defined __MACH__
+#elif defined __GNUC__ || defined __APPLE__ || defined __MACH__ || defined __FreeBSD__
         struct stat fileStat;
         int err = stat(mFilename.c_str(), &fileStat );
         if (0 != err)

code/DefaultIOSystem.cpp

@@ -40,10 +40,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 /** @file Default implementation of IOSystem using the standard C file functions */
 
-#include "DefaultIOSystem.h"
-#include "DefaultIOStream.h"
 #include "StringComparison.h"
 
+#include <assimp/DefaultIOSystem.h>
+#include <assimp/DefaultIOStream.h>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/ai_assert.h>
 #include <stdlib.h>

code/DefaultLogger.cpp

@@ -43,13 +43,14 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *  @brief Implementation of DefaultLogger (and Logger)
  */
 
-#include "DefaultIOSystem.h"
 
 // Default log streams
 #include "Win32DebugLogStream.h"
 #include "StdOStreamLogStream.h"
 #include "FileLogStream.h"
 #include "StringUtils.h"
+
+#include <assimp/DefaultIOSystem.h>
 #include <assimp/NullLogger.hpp>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/ai_assert.h>

code/Exceptional.h

@@ -42,7 +42,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_EXCEPTIONAL_H
 
 #include <stdexcept>
-#include "DefaultIOStream.h"
+#include <assimp/DefaultIOStream.h>
 using std::runtime_error;
 
 #ifdef _MSC_VER

code/Exporter.cpp

@@ -52,7 +52,6 @@ Here we implement only the C++ interface (Assimp::Exporter).
 
 #ifndef ASSIMP_BUILD_NO_EXPORT
 
-#include "DefaultIOSystem.h"
 #include "BlobIOSystem.h"
 #include "SceneCombiner.h"
 #include "BaseProcess.h"
@@ -64,11 +63,12 @@ Here we implement only the C++ interface (Assimp::Exporter).
 #include "Exceptional.h"
 #include "ScenePrivate.h"
 #include <memory>
+
+#include <assimp/DefaultIOSystem.h>
 #include <assimp/Exporter.hpp>
 #include <assimp/mesh.h>
 #include <assimp/postprocess.h>
 #include <assimp/scene.h>
-#include <memory>
 
 namespace Assimp {
 
@@ -101,7 +101,7 @@ Exporter::ExportFormatEntry gExporters[] =
     Exporter::ExportFormatEntry( "collada", "COLLADA - Digital Asset Exchange Schema", "dae", &ExportSceneCollada),
 #endif
 
-#ifndef ASSIMP_BUILD_NO_XFILE_EXPORTER
+#ifndef ASSIMP_BUILD_NO_X_EXPORTER
     Exporter::ExportFormatEntry( "x", "X Files", "x", &ExportSceneXFile,
         aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_FlipUVs),
 #endif
@@ -163,7 +163,6 @@ Exporter::ExportFormatEntry gExporters[] =
 
 class ExporterPimpl {
 public:
-
     ExporterPimpl()
         : blob()
         , mIOSystem(new Assimp::DefaultIOSystem())
@@ -171,7 +170,7 @@ public:
     {
         GetPostProcessingStepInstanceList(mPostProcessingSteps);
 
-        // grab all builtin exporters
+        // grab all built-in exporters
         mExporters.resize(ASSIMP_NUM_EXPORTERS);
         std::copy(gExporters,gExporters+ASSIMP_NUM_EXPORTERS,mExporters.begin());
     }
@@ -202,65 +201,48 @@ public:
     std::vector<Exporter::ExportFormatEntry> mExporters;
 };
 
-
 } // end of namespace Assimp
 
-
-
-
-
 using namespace Assimp;
 
-
 // ------------------------------------------------------------------------------------------------
 Exporter :: Exporter()
-: pimpl(new ExporterPimpl())
-{
+: pimpl(new ExporterPimpl()) {
+    // empty
 }
 
-
 // ------------------------------------------------------------------------------------------------
-Exporter :: ~Exporter()
-{
+Exporter::~Exporter() {
     FreeBlob();
 
     delete pimpl;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void Exporter :: SetIOHandler( IOSystem* pIOHandler)
-{
+void Exporter::SetIOHandler( IOSystem* pIOHandler) {
     pimpl->mIsDefaultIOHandler = !pIOHandler;
     pimpl->mIOSystem.reset(pIOHandler);
 }
 
-
 // ------------------------------------------------------------------------------------------------
-IOSystem* Exporter :: GetIOHandler() const
-{
+IOSystem* Exporter::GetIOHandler() const {
     return pimpl->mIOSystem.get();
 }
 
-
 // ------------------------------------------------------------------------------------------------
-bool Exporter :: IsDefaultIOHandler() const
-{
+bool Exporter::IsDefaultIOHandler() const {
     return pimpl->mIsDefaultIOHandler;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-const aiExportDataBlob* Exporter :: ExportToBlob(  const aiScene* pScene, const char* pFormatId, unsigned int, const ExportProperties* pProperties)
-{
+const aiExportDataBlob* Exporter::ExportToBlob( const aiScene* pScene, const char* pFormatId,
+                                                unsigned int, const ExportProperties* pProperties ) {
     if (pimpl->blob) {
         delete pimpl->blob;
         pimpl->blob = NULL;
     }
 
-
     std::shared_ptr<IOSystem> old = pimpl->mIOSystem;
-
     BlobIOSystem* blobio = new BlobIOSystem();
     pimpl->mIOSystem = std::shared_ptr<IOSystem>( blobio );
 
@@ -275,10 +257,8 @@ const aiExportDataBlob* Exporter :: ExportToBlob(  const aiScene* pScene, const
     return pimpl->blob;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-bool IsVerboseFormat(const aiMesh* mesh)
-{
+bool IsVerboseFormat(const aiMesh* mesh) {
     // avoid slow vector<bool> specialization
     std::vector<unsigned int> seen(mesh->mNumVertices,0);
     for(unsigned int i = 0; i < mesh->mNumFaces; ++i) {
@@ -293,10 +273,8 @@ bool IsVerboseFormat(const aiMesh* mesh)
     return true;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-bool IsVerboseFormat(const aiScene* pScene)
-{
+bool IsVerboseFormat(const aiScene* pScene) {
     for(unsigned int i = 0; i < pScene->mNumMeshes; ++i) {
         if(!IsVerboseFormat(pScene->mMeshes[i])) {
             return false;
@@ -305,10 +283,8 @@ bool IsVerboseFormat(const aiScene* pScene)
     return true;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing, const ExportProperties* pProperties)
-{
+aiReturn Exporter::Export( const aiScene* pScene, const char* pFormatId, const char* pPath, unsigned int pPreprocessing, const ExportProperties* pProperties) {
     ASSIMP_BEGIN_EXCEPTION_REGION();
 
     // when they create scenes from scratch, users will likely create them not in verbose
@@ -321,9 +297,7 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
     for (size_t i = 0; i < pimpl->mExporters.size(); ++i) {
         const Exporter::ExportFormatEntry& exp = pimpl->mExporters[i];
         if (!strcmp(exp.mDescription.id,pFormatId)) {
-
             try {
-
                 // Always create a full copy of the scene. We might optimize this one day,
                 // but for now it is the most pragmatic way.
                 aiScene* scenecopy_tmp = NULL;
@@ -342,18 +316,17 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
                     ? (priv->mPPStepsApplied & ~nonIdempotentSteps)
                     : 0u);
 
-                // If no extra postprocessing was specified, and we obtained this scene from an
+                // If no extra post-processing was specified, and we obtained this scene from an
                 // Assimp importer, apply the reverse steps automatically.
                 // TODO: either drop this, or document it. Otherwise it is just a bad surprise.
                 //if (!pPreprocessing && priv) {
                 //  pp |= (nonIdempotentSteps & priv->mPPStepsApplied);
                 //}
 
-                // If the input scene is not in verbose format, but there is at least postprocessing step that relies on it,
+                // If the input scene is not in verbose format, but there is at least post-processing step that relies on it,
                 // we need to run the MakeVerboseFormat step first.
                 bool must_join_again = false;
                 if (!is_verbose_format) {
-
                     bool verbosify = false;
                     for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++) {
                         BaseProcess* const p = pimpl->mPostProcessingSteps[a];
@@ -424,8 +397,7 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
 
                 ExportProperties emptyProperties;  // Never pass NULL ExportProperties so Exporters don't have to worry.
                 exp.mExportFunction(pPath,pimpl->mIOSystem.get(),scenecopy.get(), pProperties ? pProperties : &emptyProperties);
-            }
-            catch (DeadlyExportError& err) {
+            } catch (DeadlyExportError& err) {
                 pimpl->mError = err.what();
                 return AI_FAILURE;
             }
@@ -438,64 +410,53 @@ aiReturn Exporter :: Export( const aiScene* pScene, const char* pFormatId, const
     return AI_FAILURE;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-const char* Exporter :: GetErrorString() const
-{
+const char* Exporter::GetErrorString() const {
     return pimpl->mError.c_str();
 }
 
 
 // ------------------------------------------------------------------------------------------------
-void Exporter :: FreeBlob( )
-{
+void Exporter::FreeBlob() {
     delete pimpl->blob;
     pimpl->blob = NULL;
 
     pimpl->mError = "";
 }
 
-
 // ------------------------------------------------------------------------------------------------
-const aiExportDataBlob* Exporter :: GetBlob() const
-{
+const aiExportDataBlob* Exporter::GetBlob() const {
     return pimpl->blob;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-const aiExportDataBlob* Exporter :: GetOrphanedBlob() const
-{
+const aiExportDataBlob* Exporter::GetOrphanedBlob() const {
     const aiExportDataBlob* tmp = pimpl->blob;
     pimpl->blob = NULL;
     return tmp;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-size_t Exporter :: GetExportFormatCount() const
-{
+size_t Exporter::GetExportFormatCount() const {
     return pimpl->mExporters.size();
 }
 
 // ------------------------------------------------------------------------------------------------
-const aiExportFormatDesc* Exporter :: GetExportFormatDescription( size_t pIndex ) const
-{
-    if (pIndex >= GetExportFormatCount()) {
+const aiExportFormatDesc* Exporter::GetExportFormatDescription( size_t index ) const {
+    if (index >= GetExportFormatCount()) {
         return NULL;
     }
 
     // Return from static storage if the requested index is built-in.
-    if (pIndex < sizeof(gExporters) / sizeof(gExporters[0])) {
-        return &gExporters[pIndex].mDescription;
+    if (index < sizeof(gExporters) / sizeof(gExporters[0])) {
+        return &gExporters[index].mDescription;
     }
 
-    return &pimpl->mExporters[pIndex].mDescription;
+    return &pimpl->mExporters[index].mDescription;
 }
 
 // ------------------------------------------------------------------------------------------------
-aiReturn Exporter :: RegisterExporter(const ExportFormatEntry& desc)
-{
+aiReturn Exporter::RegisterExporter(const ExportFormatEntry& desc) {
     for(const ExportFormatEntry& e : pimpl->mExporters) {
         if (!strcmp(e.mDescription.id,desc.mDescription.id)) {
             return aiReturn_FAILURE;
@@ -506,10 +467,8 @@ aiReturn Exporter :: RegisterExporter(const ExportFormatEntry& desc)
     return aiReturn_SUCCESS;
 }
 
-
 // ------------------------------------------------------------------------------------------------
-void Exporter :: UnregisterExporter(const char* id)
-{
+void Exporter::UnregisterExporter(const char* id) {
     for(std::vector<ExportFormatEntry>::iterator it = pimpl->mExporters.begin(); it != pimpl->mExporters.end(); ++it) {
         if (!strcmp((*it).mDescription.id,id)) {
             pimpl->mExporters.erase(it);
@@ -518,29 +477,30 @@ void Exporter :: UnregisterExporter(const char* id)
     }
 }
 
-ExportProperties :: ExportProperties() {}
+// ------------------------------------------------------------------------------------------------
+ExportProperties::ExportProperties() {
+    // empty
+}
 
+// ------------------------------------------------------------------------------------------------
 ExportProperties::ExportProperties(const ExportProperties &other)
-     : mIntProperties(other.mIntProperties),
-   mFloatProperties(other.mFloatProperties),
-   mStringProperties(other.mStringProperties),
-   mMatrixProperties(other.mMatrixProperties)
-{
-
+: mIntProperties(other.mIntProperties)
+, mFloatProperties(other.mFloatProperties)
+, mStringProperties(other.mStringProperties)
+, mMatrixProperties(other.mMatrixProperties) {
+    // empty
 }
 
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool ExportProperties :: SetPropertyInteger(const char* szName, int iValue)
-{
+bool ExportProperties::SetPropertyInteger(const char* szName, int iValue) {
     return SetGenericProperty<int>(mIntProperties, szName,iValue);
 }
 
 // ------------------------------------------------------------------------------------------------
 // Set a configuration property
-bool ExportProperties :: SetPropertyFloat(const char* szName, ai_real iValue)
-{
+bool ExportProperties::SetPropertyFloat(const char* szName, ai_real iValue) {
     return SetGenericProperty<ai_real>(mFloatProperties, szName,iValue);
 }
 
@@ -602,28 +562,28 @@ bool ExportProperties :: HasPropertyInteger(const char* szName) const
 bool ExportProperties :: HasPropertyBool(const char* szName) const
 {
     return HasGenericProperty<int>(mIntProperties, szName);
-};
+}
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
 bool ExportProperties :: HasPropertyFloat(const char* szName) const
 {
     return HasGenericProperty<ai_real>(mFloatProperties, szName);
-};
+}
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
 bool ExportProperties :: HasPropertyString(const char* szName) const
 {
     return HasGenericProperty<std::string>(mStringProperties, szName);
-};
+}
 
 // ------------------------------------------------------------------------------------------------
 // Has a configuration property
 bool ExportProperties :: HasPropertyMatrix(const char* szName) const
 {
     return HasGenericProperty<aiMatrix4x4>(mMatrixProperties, szName);
-};
+}
 
 
 #endif // !ASSIMP_BUILD_NO_EXPORT

code/FBXAnimation.cpp

@@ -48,7 +48,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXParser.h"
 #include "FBXDocument.h"
 #include "FBXImporter.h"
-#include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
 #include "FBXProperties.h"
 

code/FBXBinaryTokenizer.cpp

@@ -146,18 +146,20 @@ void TokenizeError(const std::string& message, const char* begin, const char* cu
 // ------------------------------------------------------------------------------------------------
 uint32_t ReadWord(const char* input, const char*& cursor, const char* end)
 {
-    if(Offset(cursor, end) < 4) {
+    const size_t k_to_read = sizeof( uint32_t );
+    if(Offset(cursor, end) < k_to_read ) {
         TokenizeError("cannot ReadWord, out of bounds",input, cursor);
     }
 
     uint32_t word = *reinterpret_cast<const uint32_t*>(cursor);
     AI_SWAP4(word);
 
-    cursor += 4;
+    cursor += k_to_read;
 
     return word;
 }
 
+// ------------------------------------------------------------------------------------------------
 uint64_t ReadDoubleWord(const char* input, const char*& cursor, const char* end)
 {
     const size_t k_to_read = sizeof(uint64_t);
@@ -177,7 +179,7 @@ uint64_t ReadDoubleWord(const char* input, const char*& cursor, const char* end)
 // ------------------------------------------------------------------------------------------------
 uint8_t ReadByte(const char* input, const char*& cursor, const char* end)
 {
-    if(Offset(cursor, end) < 1) {
+    if(Offset(cursor, end) < sizeof( uint8_t ) ) {
         TokenizeError("cannot ReadByte, out of bounds",input, cursor);
     }
 
@@ -220,8 +222,6 @@ unsigned int ReadString(const char*& sbegin_out, const char*& send_out, const ch
     return length;
 }
 
-
-
 // ------------------------------------------------------------------------------------------------
 void ReadData(const char*& sbegin_out, const char*& send_out, const char* input, const char*& cursor, const char* end)
 {
@@ -345,7 +345,7 @@ void ReadData(const char*& sbegin_out, const char*& send_out, const char* input,
 bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor, const char* end, uint32_t const flags)
 {
     // the first word contains the offset at which this block ends
-    const uint64_t end_offset = check_flag(flags, e_flag_field_size_64_bit) ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end);
+    const uint64_t end_offset = /*check_flag(flags, e_flag_field_size_64_bit) ? ReadDoubleWord(input, cursor, end) : */ReadWord(input, cursor, end);
 
     // we may get 0 if reading reached the end of the file -
     // fbx files have a mysterious extra footer which I don't know
@@ -363,10 +363,10 @@ bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor,
     }
 
     // the second data word contains the number of properties in the scope
-    const uint64_t prop_count = check_flag(flags, e_flag_field_size_64_bit) ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end);
+    const uint64_t prop_count = /*check_flag(flags, e_flag_field_size_64_bit) ? ReadDoubleWord(input, cursor, end) : */ReadWord(input, cursor, end);
 
     // the third data word contains the length of the property list
-    const uint64_t prop_length = check_flag(flags, e_flag_field_size_64_bit) ? ReadDoubleWord(input, cursor, end) : ReadWord(input, cursor, end);
+    const uint64_t prop_length = /*check_flag(flags, e_flag_field_size_64_bit) ? ReadDoubleWord(input, cursor, end) :*/ ReadWord(input, cursor, end);
 
     // now comes the name of the scope/key
     const char* sbeg, *send;
@@ -393,7 +393,7 @@ bool ReadScope(TokenList& output_tokens, const char* input, const char*& cursor,
     // at the end of each nested block, there is a NUL record to indicate
     // that the sub-scope exists (i.e. to distinguish between P: and P : {})
     // this NUL record is 13 bytes long on 32 bit version and 25 bytes long on 64 bit.
-    const size_t sentinel_block_length = check_flag(flags, e_flag_field_size_64_bit) ? (sizeof(uint64_t) * 3 + 1) : (sizeof(uint32_t) * 3 + 1);
+    const size_t sentinel_block_length = /*check_flag(flags, e_flag_field_size_64_bit) ? (sizeof(uint64_t) * 3 + 1) : */(sizeof(uint32_t) * 3 + 1);
 
     if (Offset(input, cursor) < end_offset) {
         if (end_offset - Offset(input, cursor) < sentinel_block_length) {

code/FBXCompileConfig.h

@@ -44,6 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_COMPILECONFIG_H
 #define INCLUDED_AI_FBX_COMPILECONFIG_H
 
+#include <map>
+
 //
 #if _MSC_VER > 1500 || (defined __GNUC___)
 #   define ASSIMP_FBX_USE_UNORDERED_MULTIMAP

code/FBXConverter.cpp

@@ -58,7 +58,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <memory>
 
 #include <iterator>
-#include <sstream>
 #include <vector>
 
 namespace Assimp {
@@ -71,7 +70,7 @@ using namespace Util;
 
 #define CONVERT_FBX_TIME(time) static_cast<double>(time) / 46186158000L
 
-    // XXX vc9's debugger won't step into anonymous namespaces
+// XXX vc9's debugger won't step into anonymous namespaces
 //namespace {
 
 /** Dummy class to encapsulate the conversion process */
@@ -114,11 +113,9 @@ private:
     // collect and assign child nodes
     void ConvertNodes( uint64_t id, aiNode& parent, const aiMatrix4x4& parent_transform = aiMatrix4x4() );
 
-
     // ------------------------------------------------------------------------------------------------
     void ConvertLights( const Model& model );
 
-
     // ------------------------------------------------------------------------------------------------
     void ConvertCameras( const Model& model );
 
@@ -189,7 +186,6 @@ private:
     static const unsigned int NO_MATERIAL_SEPARATION = /* std::numeric_limits<unsigned int>::max() */
         static_cast<unsigned int>(-1);
 
-
     // ------------------------------------------------------------------------------------------------
     /**
      *  - if materialIndex == NO_MATERIAL_SEPARATION, materials are not taken into
@@ -341,8 +337,6 @@ private:
     typedef std::tuple<std::shared_ptr<KeyTimeList>, std::shared_ptr<KeyValueList>, unsigned int > KeyFrameList;
     typedef std::vector<KeyFrameList> KeyFrameListList;
 
-
-
     // ------------------------------------------------------------------------------------------------
     KeyFrameListList GetKeyframeList( const std::vector<const AnimationCurveNode*>& nodes, int64_t start, int64_t stop );
 
@@ -645,7 +639,7 @@ void Converter::ConvertLight( const Model& model, const Light& light )
 
     out_light->mName.Set( FixNodeName( model.Name() ) );
 
-    const float intensity = light.Intensity();
+    const float intensity = light.Intensity() / 100.0f;
     const aiVector3D& col = light.Color();
 
     out_light->mColorDiffuse = aiColor3D( col.x, col.y, col.z );
@@ -655,6 +649,11 @@ void Converter::ConvertLight( const Model& model, const Light& light )
 
     out_light->mColorSpecular = out_light->mColorDiffuse;
 
+    //lights are defined along negative y direction
+    out_light->mPosition = aiVector3D(0.0f);
+    out_light->mDirection = aiVector3D(0.0f, -1.0f, 0.0f);
+    out_light->mUp = aiVector3D(0.0f, 0.0f, -1.0f);
+
     switch ( light.LightType() )
     {
     case Light::Type_Point:
@@ -684,17 +683,23 @@ void Converter::ConvertLight( const Model& model, const Light& light )
         ai_assert( false );
     }
 
-    // XXX: how to best convert the near and far decay ranges?
+    float decay = light.DecayStart();
     switch ( light.DecayType() )
     {
     case Light::Decay_None:
-        out_light->mAttenuationConstant = 1.0f;
+        out_light->mAttenuationConstant = decay;
+        out_light->mAttenuationLinear = 0.0f;
+        out_light->mAttenuationQuadratic = 0.0f;
         break;
     case Light::Decay_Linear:
-        out_light->mAttenuationLinear = 1.0f;
+        out_light->mAttenuationConstant = 0.0f;
+        out_light->mAttenuationLinear = 2.0f / decay;
+        out_light->mAttenuationQuadratic = 0.0f;
         break;
     case Light::Decay_Quadratic:
-        out_light->mAttenuationQuadratic = 1.0f;
+        out_light->mAttenuationConstant = 0.0f;
+        out_light->mAttenuationLinear = 0.0f;
+        out_light->mAttenuationQuadratic = 2.0f / (decay * decay);
         break;
     case Light::Decay_Cubic:
         FBXImporter::LogWarn( "cannot represent cubic attenuation, set to Quadratic" );
@@ -713,10 +718,13 @@ void Converter::ConvertCamera( const Model& model, const Camera& cam )
     out_camera->mName.Set( FixNodeName( model.Name() ) );
 
     out_camera->mAspect = cam.AspectWidth() / cam.AspectHeight();
-    out_camera->mPosition = cam.Position();
-    out_camera->mUp = cam.UpVector();
-    out_camera->mLookAt = cam.InterestPosition() - out_camera->mPosition;
+    //cameras are defined along positive x direction
+    out_camera->mPosition = aiVector3D(0.0f);
+    out_camera->mLookAt = aiVector3D(1.0f, 0.0f, 0.0f);
+    out_camera->mUp = aiVector3D(0.0f, 1.0f, 0.0f);
     out_camera->mHorizontalFOV = AI_DEG_TO_RAD( cam.FieldOfView() );
+    out_camera->mClipPlaneNear = cam.NearPlane();
+    out_camera->mClipPlaneFar = cam.FarPlane();
 }
 
 
@@ -899,7 +907,6 @@ void Converter::GetRotationMatrix( Model::RotOrder mode, const aiVector3D& rotat
     }
 }
 
-
 bool Converter::NeedsComplexTransformationChain( const Model& model )
 {
     const PropertyTable& props = model.Props();
@@ -923,7 +930,6 @@ bool Converter::NeedsComplexTransformationChain( const Model& model )
     return false;
 }
 
-
 std::string Converter::NameTransformationChainNode( const std::string& name, TransformationComp comp )
 {
     return name + std::string( MAGIC_NODE_TAG ) + "_" + NameTransformationComp( comp );
@@ -1067,7 +1073,6 @@ void Converter::GenerateTransformationNodeChain( const Model& model,
     }
 }
 
-
 void Converter::SetupNodeMetadata( const Model& model, aiNode& nd )
 {
     const PropertyTable& props = model.Props();
@@ -1075,7 +1080,7 @@ void Converter::SetupNodeMetadata( const Model& model, aiNode& nd )
 
     // create metadata on node
     std::size_t numStaticMetaData = 2;
-    aiMetadata* data = aiMetadata::Alloc( unparsedProperties.size() + numStaticMetaData );
+    aiMetadata* data = aiMetadata::Alloc( static_cast<unsigned int>(unparsedProperties.size() + numStaticMetaData) );
     nd.mMetaData = data;
     int index = 0;
 
@@ -1132,7 +1137,6 @@ void Converter::ConvertModel( const Model& model, aiNode& nd, const aiMatrix4x4&
     }
 }
 
-
 std::vector<unsigned int> Converter::ConvertMesh( const MeshGeometry& mesh, const Model& model,
     const aiMatrix4x4& node_global_transform )
 {
@@ -1168,7 +1172,6 @@ std::vector<unsigned int> Converter::ConvertMesh( const MeshGeometry& mesh, cons
     return temp;
 }
 
-
 aiMesh* Converter::SetupEmptyMesh( const MeshGeometry& mesh )
 {
     aiMesh* const out_mesh = new aiMesh();
@@ -1188,7 +1191,6 @@ aiMesh* Converter::SetupEmptyMesh( const MeshGeometry& mesh )
     return out_mesh;
 }
 
-
 unsigned int Converter::ConvertMeshSingleMaterial( const MeshGeometry& mesh, const Model& model,
     const aiMatrix4x4& node_global_transform )
 {
@@ -1511,7 +1513,6 @@ unsigned int Converter::ConvertMeshMultiMaterial( const MeshGeometry& mesh, cons
     return static_cast<unsigned int>( meshes.size() - 1 );
 }
 
-
 void Converter::ConvertWeights( aiMesh* out, const Model& model, const MeshGeometry& geo,
     const aiMatrix4x4& node_global_transform ,
     unsigned int materialIndex,
@@ -1658,7 +1659,6 @@ void Converter::ConvertCluster( std::vector<aiBone*>& bones, const Model& /*mode
     }
 }
 
-
 void Converter::ConvertMaterialForMesh( aiMesh* out, const Model& model, const MeshGeometry& geo,
     MatIndexArray::value_type materialIndex )
 {
@@ -2133,6 +2133,16 @@ void Converter::SetShadingPropertiesCommon( aiMaterial* out_mat, const PropertyT
     if ( ok ) {
         out_mat->AddProperty( &ShininessExponent, 1, AI_MATKEY_SHININESS );
     }
+
+    const float BumpFactor = PropertyGet<float>(props, "BumpFactor", ok);
+    if (ok) {
+        out_mat->AddProperty(&BumpFactor, 1, AI_MATKEY_BUMPSCALING);
+    }
+
+    const float DispFactor = PropertyGet<float>(props, "DisplacementFactor", ok);
+    if (ok) {
+        out_mat->AddProperty(&DispFactor, 1, "$mat.displacementscaling", 0, 0);
+    }
 }
 
 
@@ -2961,10 +2971,10 @@ Converter::KeyFrameListList Converter::GetKeyframeList( const std::vector<const
             //get values within the start/stop time window
             std::shared_ptr<KeyTimeList> Keys( new KeyTimeList() );
             std::shared_ptr<KeyValueList> Values( new KeyValueList() );
-            const int count = curve->GetKeys().size();
+            const size_t count = curve->GetKeys().size();
             Keys->reserve( count );
             Values->reserve( count );
-            for ( int n = 0; n < count; n++ )
+            for (size_t n = 0; n < count; n++ )
             {
                 int64_t k = curve->GetKeys().at( n );
                 if ( k >= adj_start && k <= adj_stop )
@@ -3065,7 +3075,7 @@ void Converter::InterpolateKeys( aiVectorKey* valOut, const KeyTimeList& keys, c
             const KeyTimeList::value_type timeA = std::get<0>(kfl)->at( id0 );
             const KeyTimeList::value_type timeB = std::get<0>(kfl)->at( id1 );
 
-            const ai_real factor = timeB == timeA ? 0. : static_cast<ai_real>( ( time - timeA ) ) / ( timeB - timeA );
+            const ai_real factor = timeB == timeA ? ai_real(0.) : static_cast<ai_real>( ( time - timeA ) ) / ( timeB - timeA );
             const ai_real interpValue = static_cast<ai_real>( valueA + ( valueB - valueA ) * factor );
 
             result[ std::get<2>(kfl) ] = interpValue;

code/FBXDeformer.cpp

@@ -47,14 +47,12 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXParser.h"
 #include "FBXDocument.h"
 #include "FBXImporter.h"
-#include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
-#include "FBXProperties.h"
 
 namespace Assimp {
 namespace FBX {
 
-    using namespace Util;
+using namespace Util;
 
 // ------------------------------------------------------------------------------------------------
 Deformer::Deformer(uint64_t id, const Element& element, const Document& doc, const std::string& name)
@@ -159,8 +157,6 @@ Skin::~Skin()
 
 }
 
-
-
 }
 }
 

code/FBXDocument.cpp

@@ -55,7 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <memory>
 #include <functional>
-
+#include <map>
 
 namespace Assimp {
 namespace FBX {
@@ -78,12 +78,6 @@ 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)
 {
@@ -252,17 +246,15 @@ FileGlobalSettings::FileGlobalSettings(const Document& doc, std::shared_ptr<cons
 : props(props)
 , doc(doc)
 {
-
+    // empty
 }
 
-
 // ------------------------------------------------------------------------------------------------
 FileGlobalSettings::~FileGlobalSettings()
 {
-
+    // empty
 }
 
-
 // ------------------------------------------------------------------------------------------------
 Document::Document(const Parser& parser, const ImportSettings& settings)
 : settings(settings)
@@ -285,7 +277,6 @@ Document::Document(const Parser& parser, const ImportSettings& settings)
     ReadConnections();
 }
 
-
 // ------------------------------------------------------------------------------------------------
 Document::~Document()
 {
@@ -315,7 +306,7 @@ void Document::ReadHeader()
     const Scope& shead = *ehead->Compound();
     fbxVersion = ParseTokenAsInt(GetRequiredToken(GetRequiredElement(shead,"FBXVersion",ehead),0));
 
-    // While we maye have some success with newer files, we don't support
+    // While we may have some success with newer files, we don't support
     // the older 6.n fbx format
     if(fbxVersion < LowerSupportedVersion ) {
         DOMError("unsupported, old format version, supported are only FBX 2011, FBX 2012 and FBX 2013");
@@ -331,7 +322,6 @@ void Document::ReadHeader()
         }
     }
 
-
     const Element* const ecreator = shead["Creator"];
     if(ecreator) {
         creator = ParseTokenAsString(GetRequiredToken(*ecreator,0));

code/FBXDocument.h

@@ -240,6 +240,9 @@ public:
     fbx_simple_property(FilmWidth, float, 1.0f)
     fbx_simple_property(FilmHeight, float, 1.0f)
 
+    fbx_simple_property(NearPlane, float, 0.1f)
+    fbx_simple_property(FarPlane, float, 100.0f)
+
     fbx_simple_property(FilmAspectRatio, float, 1.0f)
     fbx_simple_property(ApertureMode, int, 0)
 
@@ -302,12 +305,12 @@ public:
     fbx_simple_property(DrawVolumetricLight, bool, true)
     fbx_simple_property(DrawGroundProjection, bool, true)
     fbx_simple_property(DrawFrontFacingVolumetricLight, bool, false)
-    fbx_simple_property(Intensity, float, 1.0f)
+    fbx_simple_property(Intensity, float, 100.0f)
     fbx_simple_property(InnerAngle, float, 0.0f)
     fbx_simple_property(OuterAngle, float, 45.0f)
     fbx_simple_property(Fog, int, 50)
-    fbx_simple_enum_property(DecayType, Decay, 0)
-    fbx_simple_property(DecayStart, int, 0)
+    fbx_simple_enum_property(DecayType, Decay, 2)
+    fbx_simple_property(DecayStart, float, 1.0f)
     fbx_simple_property(FileName, std::string, "")
 
     fbx_simple_property(EnableNearAttenuation, bool, false)
@@ -600,7 +603,7 @@ public:
 
     }
 	const int textureCount() const {
-		return textures.size();
+		return static_cast<int>(textures.size());
 	}
     const BlendMode GetBlendMode() const
     {

code/FBXImporter.cpp

@@ -44,9 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 
-#include <exception>
-#include <iterator>
-
 #include "FBXImporter.h"
 
 #include "FBXTokenizer.h"
@@ -58,6 +55,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "StreamReader.h"
 #include "MemoryIOWrapper.h"
 #include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
 
 namespace Assimp {
     template<> const std::string LogFunctions<FBXImporter>::log_prefix = "FBX: ";
@@ -99,7 +97,7 @@ FBXImporter::~FBXImporter()
 bool FBXImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
 {
     const std::string& extension = GetExtension(pFile);
-    if (extension == "fbx") {
+    if (extension == std::string( desc.mFileExtensions ) ) {
         return true;
     }
 
@@ -118,7 +116,6 @@ const aiImporterDesc* FBXImporter::GetInfo () const
     return &desc;
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Setup configuration properties for the loader
 void FBXImporter::SetupProperties(const Importer* pImp)
@@ -135,7 +132,6 @@ void FBXImporter::SetupProperties(const Importer* pImp)
     settings.optimizeEmptyAnimationCurves = pImp->GetPropertyBool(AI_CONFIG_IMPORT_FBX_OPTIMIZE_EMPTY_ANIMATION_CURVES, true);
 }
 
-
 // ------------------------------------------------------------------------------------------------
 // Imports the given file into the given scene structure.
 void FBXImporter::InternReadFile( const std::string& pFile,
@@ -165,7 +161,7 @@ void FBXImporter::InternReadFile( const std::string& pFile,
         bool is_binary = false;
         if (!strncmp(begin,"Kaydara FBX Binary",18)) {
             is_binary = true;
-            TokenizeBinary(tokens,begin,contents.size());
+            TokenizeBinary(tokens,begin,static_cast<unsigned int>(contents.size()));
         }
         else {
             Tokenize(tokens,begin);

code/FBXModel.cpp

@@ -48,9 +48,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXMeshGeometry.h"
 #include "FBXDocument.h"
 #include "FBXImporter.h"
-#include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
-#include "FBXProperties.h"
 
 namespace Assimp {
 namespace FBX {

code/FBXNodeAttribute.cpp

@@ -47,9 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXParser.h"
 #include "FBXDocument.h"
 #include "FBXImporter.h"
-#include "FBXImportSettings.h"
 #include "FBXDocumentUtil.h"
-#include "FBXProperties.h"
 
 namespace Assimp {
 namespace FBX {

code/FBXParser.cpp

@@ -51,7 +51,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #   include "../contrib/zlib/zlib.h"
 #endif
 
-
 #include "FBXTokenizer.h"
 #include "FBXParser.h"
 #include "FBXUtil.h"
@@ -583,7 +582,7 @@ void ReadBinaryDataArray(char type, uint32_t count, const char*& data, const cha
         zstream.next_in   = reinterpret_cast<Bytef*>( const_cast<char*>(data) );
         zstream.avail_in  = comp_len;
 
-        zstream.avail_out = buff.size();
+        zstream.avail_out = static_cast<uInt>(buff.size());
         zstream.next_out = reinterpret_cast<Bytef*>(&*buff.begin());
         const int ret = inflate(&zstream, Z_FINISH);
 

code/FBXProperties.h

@@ -44,14 +44,15 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_PROPERTIES_H
 #define INCLUDED_AI_FBX_PROPERTIES_H
 
-#include <map>
 #include "FBXCompileConfig.h"
 #include <memory>
+#include <string>
 
 namespace Assimp {
 namespace FBX {
 
-    class Element;
+// Forward declarations
+class Element;
 
 
 /** Represents a dynamic property. Type info added by deriving classes,

code/FBXTokenizer.h

@@ -44,7 +44,6 @@ 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 <memory>
 #include "FBXCompileConfig.h"
 #include <assimp/ai_assert.h>
 #include <vector>
@@ -84,13 +83,10 @@ enum TokenType
  *  Offers iterator protocol. Tokens are immutable. */
 class Token
 {
-
 private:
-
     static const unsigned int BINARY_MARKER = static_cast<unsigned int>(-1);
 
 public:
-
     /** construct a textual token */
     Token(const char* sbegin, const char* send, TokenType type, unsigned int line, unsigned int column);
 
@@ -100,13 +96,11 @@ public:
     ~Token();
 
 public:
-
     std::string StringContents() const {
         return std::string(begin(),end());
     }
 
 public:
-
     bool IsBinary() const {
         return column == BINARY_MARKER;
     }

code/FBXUtil.cpp

@@ -46,6 +46,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "FBXTokenizer.h"
 
 #include "TinyFormatter.h"
+#include <string>
 
 #ifndef ASSIMP_BUILD_NO_FBX_IMPORTER
 

code/FBXUtil.h

@@ -44,7 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef INCLUDED_AI_FBX_UTIL_H
 #define INCLUDED_AI_FBX_UTIL_H
 
-#include <string>
 #include "FBXCompileConfig.h"
 #include "FBXTokenizer.h"
 

code/FileLogStream.h

@@ -1,9 +1,50 @@
+/*
+Open Asset Import Library (assimp)
+----------------------------------------------------------------------
+
+Copyright (c) 2006-2017, 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 FileLofStream.h
+*/
 #ifndef ASSIMP_FILELOGSTREAM_H_INC
 #define ASSIMP_FILELOGSTREAM_H_INC
 
 #include <assimp/LogStream.hpp>
 #include <assimp/IOStream.hpp>
-#include "DefaultIOSystem.h"
+#include <assimp/DefaultIOSystem.h>
 
 namespace Assimp    {
 

code/HMPLoader.cpp

@@ -51,6 +51,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOSystem.hpp>
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/scene.h>
+#include <assimp/importerdesc.h>
 
 using namespace Assimp;
 

code/HMPLoader.h

@@ -44,11 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_HMPLOADER_H_INCLUDED
 #define AI_HMPLOADER_H_INCLUDED
 
-// public ASSIMP headers
-#include <assimp/types.h>
-#include <assimp/texture.h>
-#include <assimp/material.h>
-
 // internal headers
 #include "BaseImporter.h"
 #include "MDLLoader.h"

code/HalfLifeFileData.h

@@ -49,7 +49,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifndef AI_MDLFILEHELPER2_H_INC
 #define AI_MDLFILEHELPER2_H_INC
 
-#include "MDLFileData.h"
 #include "./../include/assimp/Compiler/pushpack1.h"
 
 namespace Assimp    {

code/IFCBoolean.cpp

@@ -47,7 +47,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "IFCUtil.h"
 #include "PolyTools.h"
 #include "ProcessHelper.h"
-#include "Defines.h"
+#include <assimp/Defines.h>
 
 #include <iterator>
 #include <tuple>
@@ -109,7 +109,7 @@ void FilterPolygon(std::vector<IfcVector3>& resultpoly)
     }
 
     IfcVector3 vmin, vmax;
-    ArrayBounds(resultpoly.data(), resultpoly.size(), vmin, vmax);
+    ArrayBounds(resultpoly.data(), static_cast<unsigned int>(resultpoly.size()), vmin, vmax);
 
     // filter our IfcFloat points - those may happen if a point lies
     // directly on the intersection line or directly on the clipping plane
@@ -132,7 +132,7 @@ void WritePolygon(std::vector<IfcVector3>& resultpoly, TempMesh& result)
     if( resultpoly.size() > 2 )
     {
         result.verts.insert(result.verts.end(), resultpoly.begin(), resultpoly.end());
-        result.vertcnt.push_back(resultpoly.size());
+        result.vertcnt.push_back(static_cast<unsigned int>(resultpoly.size()));
     }
 }
 
@@ -589,7 +589,7 @@ void ProcessPolygonalBoundedBooleanHalfSpaceDifference(const IfcPolygonalBounded
                 // to result mesh unchanged
                 if( !startedInside )
                 {
-                    outvertcnt.push_back(blackside.size());
+                    outvertcnt.push_back(static_cast<unsigned int>(blackside.size()));
                     outvert.insert(outvert.end(), blackside.begin(), blackside.end());
                     continue;
                 }

code/IFCGeometry.cpp

@@ -70,7 +70,7 @@ bool ProcessPolyloop(const IfcPolyLoop& loop, TempMesh& meshout, ConversionData&
         ++cnt;
     }
 
-    meshout.vertcnt.push_back(cnt);
+    meshout.vertcnt.push_back(static_cast<unsigned int>(cnt));
 
     // zero- or one- vertex polyloops simply ignored
     if (meshout.vertcnt.back() > 1) {
@@ -180,7 +180,7 @@ void ProcessPolygonBoundaries(TempMesh& result, const TempMesh& inmesh, size_t m
     // fill a mesh with ONLY the main polygon
     TempMesh temp;
     temp.verts.reserve(outer_polygon_size);
-    temp.vertcnt.push_back(outer_polygon_size);
+    temp.vertcnt.push_back(static_cast<unsigned int>(outer_polygon_size));
     std::copy(outer_vit, outer_vit+outer_polygon_size,
         std::back_inserter(temp.verts));
 
@@ -258,7 +258,7 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
         return;
     }
 
-    const unsigned int cnt_segments = std::max(2u,static_cast<unsigned int>(16 * std::fabs(max_angle)/AI_MATH_HALF_PI_F));
+    const unsigned int cnt_segments = std::max(2u,static_cast<unsigned int>(conv.settings.cylindricalTessellation * std::fabs(max_angle)/AI_MATH_HALF_PI_F));
     const IfcFloat delta = max_angle/cnt_segments;
 
     has_area = has_area && std::fabs(max_angle) < AI_MATH_TWO_PI_F*0.99;
@@ -305,8 +305,8 @@ void ProcessRevolvedAreaSolid(const IfcRevolvedAreaSolid& solid, TempMesh& resul
         for(size_t i = 0; i < size; ++i ) {
             out.push_back(out[i*4]);
         }
-        result.vertcnt.push_back(size);
-        result.vertcnt.push_back(size);
+        result.vertcnt.push_back(static_cast<unsigned int>(size));
+        result.vertcnt.push_back(static_cast<unsigned int>(size));
     }
 
     IfcMatrix4 trafo;
@@ -327,7 +327,7 @@ void ProcessSweptDiskSolid(const IfcSweptDiskSolid solid, TempMesh& result, Conv
         return;
     }
 
-    const unsigned int cnt_segments = 16;
+    const unsigned int cnt_segments = conv.settings.cylindricalTessellation;
     const IfcFloat deltaAngle = AI_MATH_TWO_PI/cnt_segments;
 
     const size_t samples = curve->EstimateSampleCount(solid.StartParam,solid.EndParam);
@@ -638,7 +638,7 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
                     out.push_back(in[i]);
             }
 
-            curmesh.vertcnt.push_back(in.size());
+            curmesh.vertcnt.push_back(static_cast<unsigned int>(in.size()));
             if( openings && in.size() > 2 ) {
                 if( GenerateOpenings(*conv.apply_openings, nors, temp, true, true, dir) ) {
                     ++sides_with_v_openings;
@@ -665,7 +665,7 @@ void ProcessExtrudedArea(const IfcExtrudedAreaSolid& solid, const TempMesh& curv
 
         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());
+        profile2D->vertcnt.push_back(static_cast<unsigned int>(in.size()));
         conv.collect_openings->push_back(TempOpening(&solid, dir, profile, profile2D));
 
         ai_assert(result.IsEmpty());
@@ -810,7 +810,7 @@ bool ProcessGeometricItem(const IfcRepresentationItem& geo, unsigned int matid,
     aiMesh* const mesh = meshtmp->ToMesh();
     if(mesh) {
         mesh->mMaterialIndex = matid;
-        mesh_indices.push_back(conv.meshes.size());
+        mesh_indices.push_back(static_cast<unsigned int>(conv.meshes.size()));
         conv.meshes.push_back(mesh);
         return true;
     }
@@ -827,9 +827,8 @@ void AssignAddedMeshes(std::vector<unsigned int>& mesh_indices,aiNode* nd,
         std::sort(mesh_indices.begin(),mesh_indices.end());
         std::vector<unsigned int>::iterator it_end = std::unique(mesh_indices.begin(),mesh_indices.end());
 
-        const size_t size = std::distance(mesh_indices.begin(),it_end);
+        nd->mNumMeshes = static_cast<unsigned int>(std::distance(mesh_indices.begin(),it_end));
 
-        nd->mNumMeshes = size;
         nd->mMeshes = new unsigned int[nd->mNumMeshes];
         for(unsigned int i = 0; i < nd->mNumMeshes; ++i) {
             nd->mMeshes[i] = mesh_indices[i];

code/IFCLoader.cpp

@@ -58,10 +58,10 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include "IFCUtil.h"
 
-#include "StreamReader.h"
 #include "MemoryIOWrapper.h"
 #include <assimp/scene.h>
 #include <assimp/Importer.hpp>
+#include <assimp/importerdesc.h>
 
 
 namespace Assimp {
@@ -108,7 +108,7 @@ static const aiImporterDesc desc = {
     0,
     0,
     0,
-    "ifc ifczip"
+    "ifc ifczip stp"
 };
 
 
@@ -128,11 +128,9 @@ IFCImporter::~IFCImporter()
 bool IFCImporter::CanRead( const std::string& pFile, IOSystem* pIOHandler, bool checkSig) const
 {
     const std::string& extension = GetExtension(pFile);
-    if (extension == "ifc" || extension == "ifczip") {
+    if (extension == "ifc" || extension == "ifczip" || extension == "stp" ) {
         return true;
-    }
-
-    else if ((!extension.length() || checkSig) && pIOHandler)   {
+    } else if ((!extension.length() || checkSig) && pIOHandler)   {
         // note: this is the common identification for STEP-encoded files, so
         // it is only unambiguous as long as we don't support any further
         // file formats with STEP as their encoding.
@@ -155,11 +153,10 @@ const aiImporterDesc* IFCImporter::GetInfo () const
 void IFCImporter::SetupProperties(const Importer* pImp)
 {
     settings.skipSpaceRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_SPACE_REPRESENTATIONS,true);
-    settings.skipCurveRepresentations = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_SKIP_CURVE_REPRESENTATIONS,true);
     settings.useCustomTriangulation = pImp->GetPropertyBool(AI_CONFIG_IMPORT_IFC_CUSTOM_TRIANGULATION,true);
-
-    settings.conicSamplingAngle = 10.f;
-    settings.skipAnnotations = true;
+    settings.conicSamplingAngle = std::min(std::max(pImp->GetPropertyFloat(AI_CONFIG_IMPORT_IFC_SMOOTHING_ANGLE, AI_IMPORT_IFC_DEFAULT_SMOOTHING_ANGLE), 5.0f), 120.0f);
+	settings.cylindricalTessellation = std::min(std::max(pImp->GetPropertyInteger(AI_CONFIG_IMPORT_IFC_CYLINDRICAL_TESSELLATION, AI_IMPORT_IFC_DEFAULT_CYLINDRICAL_TESSELLATION), 3), 180);
+	settings.skipAnnotations = true;
 }
 
 
@@ -707,7 +704,7 @@ aiNode* ProcessSpatialStructure(aiNode* parent, const IfcProduct& el, Conversion
         }
 
         if (!properties.empty()) {
-            aiMetadata* data = aiMetadata::Alloc( properties.size() );
+            aiMetadata* data = aiMetadata::Alloc( static_cast<unsigned int>(properties.size()) );
             unsigned int index( 0 );
             for ( const Metadata::value_type& kv : properties ) {
                 data->Set( index++, kv.first, aiString( kv.second ) );

code/IFCLoader.h

@@ -107,18 +107,18 @@ public:
     {
         Settings()
             : skipSpaceRepresentations()
-            , skipCurveRepresentations()
             , useCustomTriangulation()
             , skipAnnotations()
             , conicSamplingAngle(10.f)
+			, cylindricalTessellation(32)
         {}
 
 
         bool skipSpaceRepresentations;
-        bool skipCurveRepresentations;
         bool useCustomTriangulation;
         bool skipAnnotations;
         float conicSamplingAngle;
+		int cylindricalTessellation;
     };
 
 

code/IFCMaterial.cpp

@@ -159,7 +159,7 @@ unsigned int ProcessMaterials(uint64_t id, unsigned int prevMatId, ConversionDat
                         FillMaterial(mat.get(), surf, conv);
 
                         conv.materials.push_back(mat.release());
-                        unsigned int matindex = conv.materials.size() - 1;
+                        unsigned int matindex = static_cast<unsigned int>(conv.materials.size() - 1);
                         conv.cached_materials[surf] = matindex;
                         return matindex;
             }

code/IFCOpenings.cpp

@@ -364,7 +364,7 @@ void InsertWindowContours(const ContourVector& contours,
                     }
 
                     if (const size_t d = curmesh.verts.size()-old) {
-                        curmesh.vertcnt.push_back(d);
+                        curmesh.vertcnt.push_back(static_cast<unsigned int>(d));
                         std::reverse(curmesh.verts.rbegin(),curmesh.verts.rbegin()+d);
                     }
                     if (n == very_first_hit) {
@@ -549,7 +549,7 @@ void CleanupOuterContour(const std::vector<IfcVector2>& contour_flat, TempMesh&
                 clipper.Execute(ClipperLib::ctIntersection,clipped,ClipperLib::pftNonZero,ClipperLib::pftNonZero);
 
                 for(const ClipperLib::ExPolygon& ex : clipped) {
-                    iold.push_back(ex.outer.size());
+                    iold.push_back(static_cast<unsigned int>(ex.outer.size()));
                     for(const ClipperLib::IntPoint& point : ex.outer) {
                         vold.push_back(IfcVector3(
                             from_int64(point.X),
@@ -901,13 +901,21 @@ size_t CloseWindows(ContourVector& contours,
             curmesh.verts.reserve(curmesh.verts.size() + (*it).contour.size() * 4);
             curmesh.vertcnt.reserve(curmesh.vertcnt.size() + (*it).contour.size());
 
+			bool reverseCountourFaces = false;
+
             // compare base poly normal and contour normal to detect if we need to reverse the face winding
-            IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal( curmesh.verts.data(), curmesh.vertcnt.front());
-            std::vector<IfcVector3> worldSpaceContourVtx( it->contour.size());
-            for( size_t a = 0; a < it->contour.size(); ++a )
-                worldSpaceContourVtx[a] = minv * IfcVector3( it->contour[a].x, it->contour[a].y, 0.0);
-            IfcVector3 contourNormal = TempMesh::ComputePolygonNormal( worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
-            bool reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
+			if(curmesh.vertcnt.size() > 0) {
+				IfcVector3 basePolyNormal = TempMesh::ComputePolygonNormal(curmesh.verts.data(), curmesh.vertcnt.front());
+				
+				std::vector<IfcVector3> worldSpaceContourVtx(it->contour.size());
+				
+				for(size_t a = 0; a < it->contour.size(); ++a)
+					worldSpaceContourVtx[a] = minv * IfcVector3(it->contour[a].x, it->contour[a].y, 0.0);
+				
+				IfcVector3 contourNormal = TempMesh::ComputePolygonNormal(worldSpaceContourVtx.data(), worldSpaceContourVtx.size());
+				
+				reverseCountourFaces = (contourNormal * basePolyNormal) > 0.0;
+			}
 
             // XXX this algorithm is really a bit inefficient - both in terms
             // of constant factor and of asymptotic runtime.

code/IFCProfile.cpp

@@ -59,7 +59,7 @@ void ProcessPolyLine(const IfcPolyline& def, TempMesh& meshout, ConversionData&
         ConvertCartesianPoint(t,cp);
         meshout.verts.push_back(t);
     }
-    meshout.vertcnt.push_back(meshout.verts.size());
+    meshout.vertcnt.push_back(static_cast<unsigned int>(meshout.verts.size()));
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -80,7 +80,7 @@ bool ProcessCurve(const IfcCurve& curve,  TempMesh& meshout, ConversionData& con
             IFCImporter::LogError(cv.s+ " (error occurred while processing curve)");
             return false;
         }
-        meshout.vertcnt.push_back(meshout.verts.size());
+        meshout.vertcnt.push_back(static_cast<unsigned int>(meshout.verts.size()));
         return true;
     }
 
@@ -101,7 +101,7 @@ void ProcessOpenProfile(const IfcArbitraryOpenProfileDef& def, TempMesh& meshout
 }
 
 // ------------------------------------------------------------------------------------------------
-void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& /*conv*/)
+void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh& meshout, ConversionData& conv)
 {
     if(const IfcRectangleProfileDef* const cprofile = def.ToPtr<IfcRectangleProfileDef>()) {
         const IfcFloat x = cprofile->XDim*0.5f, y = cprofile->YDim*0.5f;
@@ -117,7 +117,7 @@ void ProcessParametrizedProfile(const IfcParameterizedProfileDef& def, TempMesh&
         if(def.ToPtr<IfcCircleHollowProfileDef>()) {
             // TODO
         }
-        const size_t segments = 32;
+        const size_t segments = conv.settings.cylindricalTessellation;
         const IfcFloat delta = AI_MATH_TWO_PI_F/segments, radius = circle->Radius;
 
         meshout.verts.reserve(segments);

code/IFCUtil.cpp

@@ -49,7 +49,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "IFCUtil.h"
 #include "PolyTools.h"
 #include "ProcessHelper.h"
-#include "Defines.h"
+#include <assimp/Defines.h>
 
 namespace Assimp {
     namespace IFC {
@@ -180,7 +180,7 @@ IfcVector3 TempMesh::ComputePolygonNormal(const IfcVector3* vtcs, size_t cnt, bo
     }
 
     IfcVector3 nor;
-    NewellNormal<3, 3, 3>(nor, cnt, &temp[0], &temp[1], &temp[2]);
+    NewellNormal<3, 3, 3>(nor, static_cast<int>(cnt), &temp[0], &temp[1], &temp[2]);
     return normalize ? nor.Normalize() : nor;
 }
 
@@ -548,7 +548,7 @@ void ConvertCartesianPoint(IfcVector3& out, const IfcCartesianPoint& in)
 {
     out = IfcVector3();
     for(size_t i = 0; i < in.Coordinates.size(); ++i) {
-        out[i] = in.Coordinates[i];
+        out[static_cast<unsigned int>(i)] = in.Coordinates[i];
     }
 }
 
@@ -564,7 +564,7 @@ void ConvertDirection(IfcVector3& out, const IfcDirection& in)
 {
     out = IfcVector3();
     for(size_t i = 0; i < in.DirectionRatios.size(); ++i) {
-        out[i] = in.DirectionRatios[i];
+        out[static_cast<unsigned int>(i)] = in.DirectionRatios[i];
     }
     const IfcFloat len = out.Length();
     if (len<1e-6) {

code/IOStreamBuffer.h

@@ -44,8 +44,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/IOStream.hpp>
 #include "ParsingUtils.h"
 
-#include <iostream>
-
 namespace Assimp {
 
 // ---------------------------------------------------------------------------

code/IRRLoader.cpp

@@ -65,7 +65,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/scene.h>
 #include <assimp/IOSystem.hpp>
 #include <assimp/postprocess.h>
-
+#include <assimp/importerdesc.h>
 
 using namespace Assimp;
 using namespace irr;
@@ -215,7 +215,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
         SkyboxVertex( l,-l,-l,  0, 0, 1,   0.0,1.0),
         SkyboxVertex( l, l,-l,  0, 0, 1,   0.0,0.0),
         SkyboxVertex(-l, l,-l,  0, 0, 1,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = materials.size()-6u;
+    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-6u);
 
     // LEFT SIDE
     meshes.push_back( BuildSingleQuadMesh(
@@ -223,7 +223,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
         SkyboxVertex( l,-l, l,  -1, 0, 0,   0.0,1.0),
         SkyboxVertex( l, l, l,  -1, 0, 0,   0.0,0.0),
         SkyboxVertex( l, l,-l,  -1, 0, 0,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = materials.size()-5u;
+    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-5u);
 
     // BACK SIDE
     meshes.push_back( BuildSingleQuadMesh(
@@ -231,7 +231,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
         SkyboxVertex(-l,-l, l,  0, 0, -1,   0.0,1.0),
         SkyboxVertex(-l, l, l,  0, 0, -1,   0.0,0.0),
         SkyboxVertex( l, l, l,  0, 0, -1,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = materials.size()-4u;
+    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-4u);
 
     // RIGHT SIDE
     meshes.push_back( BuildSingleQuadMesh(
@@ -239,7 +239,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
         SkyboxVertex(-l,-l,-l,  1, 0, 0,   0.0,1.0),
         SkyboxVertex(-l, l,-l,  1, 0, 0,   0.0,0.0),
         SkyboxVertex(-l, l, l,  1, 0, 0,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = materials.size()-3u;
+    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-3u);
 
     // TOP SIDE
     meshes.push_back( BuildSingleQuadMesh(
@@ -247,7 +247,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
         SkyboxVertex( l, l, l,  0, -1, 0,   0.0,1.0),
         SkyboxVertex(-l, l, l,  0, -1, 0,   0.0,0.0),
         SkyboxVertex(-l, l,-l,  0, -1, 0,   1.0,0.0)) );
-    meshes.back()->mMaterialIndex = materials.size()-2u;
+    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-2u);
 
     // BOTTOM SIDE
     meshes.push_back( BuildSingleQuadMesh(
@@ -255,7 +255,7 @@ void IRRImporter::BuildSkybox(std::vector<aiMesh*>& meshes, std::vector<aiMateri
         SkyboxVertex( l,-l,-l,  0,  1, 0,   1.0,0.0),
         SkyboxVertex(-l,-l,-l,  0,  1, 0,   1.0,1.0),
         SkyboxVertex(-l,-l, l,  0,  1, 0,   0.0,1.0)) );
-    meshes.back()->mMaterialIndex = materials.size()-1u;
+    meshes.back()->mMaterialIndex = static_cast<unsigned int>(materials.size()-1u);
 }
 
 // ------------------------------------------------------------------------------------------------
@@ -642,7 +642,7 @@ void SetupMapping (aiMaterial* mat, aiTextureMapping mode, const aiVector3D& axi
         delete[] mat->mProperties;
         mat->mProperties = new aiMaterialProperty*[p.size()*2];
 
-        mat->mNumAllocated = p.size()*2;
+        mat->mNumAllocated = static_cast<unsigned int>(p.size()*2);
     }
     mat->mNumProperties = (unsigned int)p.size();
     ::memcpy(mat->mProperties,&p[0],sizeof(void*)*mat->mNumProperties);

code/IRRMeshLoader.cpp

@@ -54,9 +54,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <assimp/DefaultLogger.hpp>
 #include <assimp/material.h>
 #include <assimp/scene.h>
+#include <assimp/importerdesc.h>
 #include "Macros.h"
 
-
 using namespace Assimp;
 using namespace irr;
 using namespace irr::io;

code/Importer.cpp

@@ -45,6 +45,7 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #include <assimp/version.h>
 #include <assimp/config.h>
+#include <assimp/importerdesc.h>
 
 // ------------------------------------------------------------------------------------------------
 /* Uncomment this line to prevent Assimp from catching unknown exceptions.
@@ -65,8 +66,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include "BaseImporter.h"
 #include "BaseProcess.h"
 
-#include "DefaultIOStream.h"
-#include "DefaultIOSystem.h"
 #include "DefaultProgressHandler.h"
 #include "GenericProperty.h"
 #include "ProcessHelper.h"
@@ -81,6 +80,9 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <memory>
 #include <cctype>
 
+#include <assimp/DefaultIOStream.h>
+#include <assimp/DefaultIOSystem.h>
+
 #ifndef ASSIMP_BUILD_NO_VALIDATEDS_PROCESS
 #   include "ValidateDataStructure.h"
 #endif
@@ -654,7 +656,7 @@ const aiScene* Importer::ReadFile( const char* _pFile, unsigned int pFlags)
         uint32_t fileSize = 0;
         if (fileIO)
         {
-            fileSize = fileIO->FileSize();
+            fileSize = static_cast<uint32_t>(fileIO->FileSize());
             pimpl->mIOHandler->Close( fileIO );
         }
 
@@ -790,7 +792,7 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
     for( unsigned int a = 0; a < pimpl->mPostProcessingSteps.size(); a++)   {
 
         BaseProcess* process = pimpl->mPostProcessingSteps[a];
-        pimpl->mProgressHandler->UpdatePostProcess( a, pimpl->mPostProcessingSteps.size() );
+        pimpl->mProgressHandler->UpdatePostProcess(static_cast<int>(a), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
         if( process->IsActive( pFlags)) {
 
             if (profiler) {
@@ -825,7 +827,7 @@ const aiScene* Importer::ApplyPostProcessing(unsigned int pFlags)
         }
 #endif // ! DEBUG
     }
-    pimpl->mProgressHandler->UpdatePostProcess( pimpl->mPostProcessingSteps.size(), pimpl->mPostProcessingSteps.size() );
+    pimpl->mProgressHandler->UpdatePostProcess( static_cast<int>(pimpl->mPostProcessingSteps.size()), static_cast<int>(pimpl->mPostProcessingSteps.size()) );
 
     // update private scene flags
   if( pimpl->mScene )

code/Importer.h

@@ -44,8 +44,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #define INCLUDED_AI_IMPORTER_H
 
 #include <map>
-#include <string>
 #include <vector>
+#include <string>
 #include <assimp/matrix4x4.h>
 
 struct aiScene;

code/ImporterRegistry.cpp

@@ -46,6 +46,9 @@ directly (unless you are adding new loaders), instead use the
 corresponding preprocessor flag to selectively disable formats.
 */
 
+#include <vector>
+#include "BaseImporter.h"
+
 // ------------------------------------------------------------------------------------------------
 // Importers
 // (include_new_importers_here)