Merge branch 'master' into assimpview_unicode

CMakeLists.txt

@@ -151,8 +151,8 @@ ELSE()
 ENDIF(NOT BUILD_SHARED_LIBS)
 
 # Define here the needed parameters
-SET (ASSIMP_VERSION_MAJOR 4)
+SET (ASSIMP_VERSION_MAJOR 5)
-SET (ASSIMP_VERSION_MINOR 1)
+SET (ASSIMP_VERSION_MINOR 0)
 SET (ASSIMP_VERSION_PATCH 0)
 SET (ASSIMP_VERSION ${ASSIMP_VERSION_MAJOR}.${ASSIMP_VERSION_MINOR}.${ASSIMP_VERSION_PATCH})
 SET (ASSIMP_SOVERSION 4)
@@ -255,6 +255,7 @@ IF (CMAKE_BUILD_TYPE STREQUAL "Debug")
 ELSE()
   SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fembed-bitcode -O3")
   SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fembed-bitcode -O3")
+  # Experimental for pdb generation
 ENDIF()
 
 ENDIF( IOS )

assimpTargets-release.cmake.in

@@ -53,6 +53,7 @@ endif()
 set(CMAKE_IMPORT_FILE_VERSION)
 
 get_filename_component(ASSIMP_ROOT_DIR "@CMAKE_INSTALL_PREFIX@" REALPATH)
+
 set( ASSIMP_CXX_FLAGS ) # dynamically linked library
 set( ASSIMP_LINK_FLAGS "" )
 set( ASSIMP_LIBRARY_DIRS "${ASSIMP_ROOT_DIR}/@ASSIMP_LIB_INSTALL_DIR@")

code/FBXExportNode.h

@@ -59,12 +59,11 @@ namespace FBX {
     class Node;
 }
 
-class FBX::Node
+class FBX::Node {
-{
+public: 
-public: // public data members
     // TODO: accessors
     std::string name; // node name
-    std::vector<FBX::Property> properties; // node properties
+    std::vector<FBX::FBXExportProperty> properties; // node properties
     std::vector<FBX::Node> children; // child nodes
 
     // some nodes always pretend they have children...
@@ -215,7 +214,7 @@ public: // static member functions
         Assimp::StreamWriterLE& s,
         bool binary, int indent
     ) {
-        FBX::Property p(value);
+        FBX::FBXExportProperty p(value);
         FBX::Node node(name, p);
         node.Dump(s, binary, indent);
     }

code/FBXExportProperty.cpp

@@ -53,186 +53,209 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #include <sstream> // ostringstream
 
 namespace Assimp {
+namespace FBX {
+
 // constructors for single element properties
 
-FBX::Property::Property(bool v)
+FBXExportProperty::FBXExportProperty(bool v)
-    : type('C'), data(1)
+: type('C')
-{
+, data(1) {
-    data = {uint8_t(v)};
+    data = {
+        uint8_t(v)
+    };
 }
 
-FBX::Property::Property(int16_t v) : type('Y'), data(2)
+FBXExportProperty::FBXExportProperty(int16_t v)
-{
+: type('Y')
+, data(2) {
     uint8_t* d = data.data();
     (reinterpret_cast<int16_t*>(d))[0] = v;
 }
 
-FBX::Property::Property(int32_t v) : type('I'), data(4)
+FBXExportProperty::FBXExportProperty(int32_t v)
-{
+: type('I')
+, data(4) {
     uint8_t* d = data.data();
     (reinterpret_cast<int32_t*>(d))[0] = v;
 }
 
-FBX::Property::Property(float v) : type('F'), data(4)
+FBXExportProperty::FBXExportProperty(float v)
-{
+: type('F')
+, data(4) {
     uint8_t* d = data.data();
     (reinterpret_cast<float*>(d))[0] = v;
 }
 
-FBX::Property::Property(double v) : type('D'), data(8)
+FBXExportProperty::FBXExportProperty(double v)
-{
+: type('D')
+, data(8) {
     uint8_t* d = data.data();
     (reinterpret_cast<double*>(d))[0] = v;
 }
 
-FBX::Property::Property(int64_t v) : type('L'), data(8)
+FBXExportProperty::FBXExportProperty(int64_t v)
-{
+: type('L')
+, data(8) {
     uint8_t* d = data.data();
     (reinterpret_cast<int64_t*>(d))[0] = v;
 }
 
-
 // constructors for array-type properties
 
-FBX::Property::Property(const char* c, bool raw)
+FBXExportProperty::FBXExportProperty(const char* c, bool raw)
-    : Property(std::string(c), raw)
+: FBXExportProperty(std::string(c), raw) {
-{}
+    // empty
+}
 
 // strings can either be saved as "raw" (R) data, or "string" (S) data
-FBX::Property::Property(const std::string& s, bool raw)
+FBXExportProperty::FBXExportProperty(const std::string& s, bool raw)
-    : type(raw ? 'R' : 'S'), data(s.size())
+: type(raw ? 'R' : 'S')
-{
+, data(s.size()) {
     for (size_t i = 0; i < s.size(); ++i) {
         data[i] = uint8_t(s[i]);
     }
 }
 
-FBX::Property::Property(const std::vector<uint8_t>& r)
+FBXExportProperty::FBXExportProperty(const std::vector<uint8_t>& r)
-    : type('R'), data(r)
+: type('R')
-{}
+, data(r) {
+    // empty
+}
 
-FBX::Property::Property(const std::vector<int32_t>& va)
+FBXExportProperty::FBXExportProperty(const std::vector<int32_t>& va)
-    : type('i'), data(4*va.size())
+: type('i')
-{
+, data(4 * va.size() ) {
     int32_t* d = reinterpret_cast<int32_t*>(data.data());
-    for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
+    for (size_t i = 0; i < va.size(); ++i) {
+        d[i] = va[i];
+    }
 }
 
-FBX::Property::Property(const std::vector<int64_t>& va)
+FBXExportProperty::FBXExportProperty(const std::vector<int64_t>& va)
-    : type('l'), data(8*va.size())
+: type('l')
-{
+, data(8 * va.size()) {
     int64_t* d = reinterpret_cast<int64_t*>(data.data());
-    for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
+    for (size_t i = 0; i < va.size(); ++i) {
+        d[i] = va[i];
+    }
 }
 
-FBX::Property::Property(const std::vector<float>& va)
+FBXExportProperty::FBXExportProperty(const std::vector<float>& va)
-    : type('f'), data(4*va.size())
+: type('f')
-{
+, data(4 * va.size()) {
     float* d = reinterpret_cast<float*>(data.data());
-    for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
+    for (size_t i = 0; i < va.size(); ++i) {
+        d[i] = va[i];
+    }
 }
 
-FBX::Property::Property(const std::vector<double>& va)
+FBXExportProperty::FBXExportProperty(const std::vector<double>& va)
-    : type('d'), data(8*va.size())
+: type('d')
-{
+, data(8 * va.size()) {
     double* d = reinterpret_cast<double*>(data.data());
-    for (size_t i = 0; i < va.size(); ++i) { d[i] = va[i]; }
+    for (size_t i = 0; i < va.size(); ++i) {
+        d[i] = va[i];
+    }
 }
 
-FBX::Property::Property(const aiMatrix4x4& vm)
+FBXExportProperty::FBXExportProperty(const aiMatrix4x4& vm)
-    : type('d'), data(8*16)
+: type('d')
-{
+, data(8 * 16) {
     double* d = reinterpret_cast<double*>(data.data());
     for (unsigned int c = 0; c < 4; ++c) {
         for (unsigned int r = 0; r < 4; ++r) {
-            d[4*c+r] = vm[r][c];
+            d[4 * c + r] = vm[r][c];
         }
     }
 }
 
 // public member functions
 
-size_t FBX::Property::size()
+size_t FBXExportProperty::size() {
-{
     switch (type) {
-    case 'C': case 'Y': case 'I': case 'F': case 'D': case 'L':
+        case 'C':
-        return data.size() + 1;
+        case 'Y':
-    case 'S': case 'R':
+        case 'I':
-        return data.size() + 5;
+        case 'F':
-    case 'i': case 'd':
+        case 'D':
-        return data.size() + 13;
+        case 'L':
-    default:
+            return data.size() + 1;
-        throw DeadlyExportError("Requested size on property of unknown type");
+        case 'S':
+        case 'R':
+            return data.size() + 5;
+        case 'i':
+        case 'd':
+            return data.size() + 13;
+        default:
+            throw DeadlyExportError("Requested size on property of unknown type");
     }
 }
 
-void FBX::Property::DumpBinary(Assimp::StreamWriterLE &s)
+void FBXExportProperty::DumpBinary(Assimp::StreamWriterLE& s) {
-{
     s.PutU1(type);
     uint8_t* d = data.data();
     size_t N;
     switch (type) {
-    case 'C': s.PutU1(*(reinterpret_cast<uint8_t*>(d))); return;
+        case 'C': s.PutU1(*(reinterpret_cast<uint8_t*>(d))); return;
-    case 'Y': s.PutI2(*(reinterpret_cast<int16_t*>(d))); return;
+        case 'Y': s.PutI2(*(reinterpret_cast<int16_t*>(d))); return;
-    case 'I': s.PutI4(*(reinterpret_cast<int32_t*>(d))); return;
+        case 'I': s.PutI4(*(reinterpret_cast<int32_t*>(d))); return;
-    case 'F': s.PutF4(*(reinterpret_cast<float*>(d))); return;
+        case 'F': s.PutF4(*(reinterpret_cast<float*>(d))); return;
-    case 'D': s.PutF8(*(reinterpret_cast<double*>(d))); return;
+        case 'D': s.PutF8(*(reinterpret_cast<double*>(d))); return;
-    case 'L': s.PutI8(*(reinterpret_cast<int64_t*>(d))); return;
+        case 'L': s.PutI8(*(reinterpret_cast<int64_t*>(d))); return;
-    case 'S':
+        case 'S':
-    case 'R':
+        case 'R':
-        s.PutU4(uint32_t(data.size()));
+            s.PutU4(uint32_t(data.size()));
-        for (size_t i = 0; i < data.size(); ++i) { s.PutU1(data[i]); }
+            for (size_t i = 0; i < data.size(); ++i) { s.PutU1(data[i]); }
-        return;
+            return;
-    case 'i':
+        case 'i':
-        N = data.size() / 4;
+            N = data.size() / 4;
-        s.PutU4(uint32_t(N)); // number of elements
+            s.PutU4(uint32_t(N)); // number of elements
-        s.PutU4(0); // no encoding (1 would be zip-compressed)
+            s.PutU4(0); // no encoding (1 would be zip-compressed)
-        // TODO: compress if large?
+            // TODO: compress if large?
-        s.PutU4(uint32_t(data.size())); // data size
+            s.PutU4(uint32_t(data.size())); // data size
-        for (size_t i = 0; i < N; ++i) {
+            for (size_t i = 0; i < N; ++i) {
-            s.PutI4((reinterpret_cast<int32_t*>(d))[i]);
+                s.PutI4((reinterpret_cast<int32_t*>(d))[i]);
-        }
+            }
-        return;
+            return;
-    case 'l':
+        case 'l':
-        N = data.size() / 8;
+            N = data.size() / 8;
-        s.PutU4(uint32_t(N)); // number of elements
+            s.PutU4(uint32_t(N)); // number of elements
-        s.PutU4(0); // no encoding (1 would be zip-compressed)
+            s.PutU4(0); // no encoding (1 would be zip-compressed)
-        // TODO: compress if large?
+            // TODO: compress if large?
-        s.PutU4(uint32_t(data.size())); // data size
+            s.PutU4(uint32_t(data.size())); // data size
-        for (size_t i = 0; i < N; ++i) {
+            for (size_t i = 0; i < N; ++i) {
-            s.PutI8((reinterpret_cast<int64_t*>(d))[i]);
+                s.PutI8((reinterpret_cast<int64_t*>(d))[i]);
-        }
+            }
-        return;
+            return;
-    case 'f':
+        case 'f':
-        N = data.size() / 4;
+            N = data.size() / 4;
-        s.PutU4(uint32_t(N)); // number of elements
+            s.PutU4(uint32_t(N)); // number of elements
-        s.PutU4(0); // no encoding (1 would be zip-compressed)
+            s.PutU4(0); // no encoding (1 would be zip-compressed)
-        // TODO: compress if large?
+            // TODO: compress if large?
-        s.PutU4(uint32_t(data.size())); // data size
+            s.PutU4(uint32_t(data.size())); // data size
-        for (size_t i = 0; i < N; ++i) {
+            for (size_t i = 0; i < N; ++i) {
-            s.PutF4((reinterpret_cast<float*>(d))[i]);
+                s.PutF4((reinterpret_cast<float*>(d))[i]);
-        }
+            }
-        return;
+            return;
-    case 'd':
+        case 'd':
-        N = data.size() / 8;
+            N = data.size() / 8;
-        s.PutU4(uint32_t(N)); // number of elements
+            s.PutU4(uint32_t(N)); // number of elements
-        s.PutU4(0); // no encoding (1 would be zip-compressed)
+            s.PutU4(0); // no encoding (1 would be zip-compressed)
-        // TODO: compress if large?
+            // TODO: compress if large?
-        s.PutU4(uint32_t(data.size())); // data size
+            s.PutU4(uint32_t(data.size())); // data size
-        for (size_t i = 0; i < N; ++i) {
+            for (size_t i = 0; i < N; ++i) {
-            s.PutF8((reinterpret_cast<double*>(d))[i]);
+                s.PutF8((reinterpret_cast<double*>(d))[i]);
-        }
+            }
-        return;
+            return;
-    default:
+        default:
-        std::ostringstream err;
+            std::ostringstream err;
-        err << "Tried to dump property with invalid type '";
+            err << "Tried to dump property with invalid type '";
-        err << type << "'!";
+            err << type << "'!";
-        throw DeadlyExportError(err.str());
+            throw DeadlyExportError(err.str());
     }
 }
 
-void FBX::Property::DumpAscii(Assimp::StreamWriterLE &outstream, int indent)
+void FBXExportProperty::DumpAscii(Assimp::StreamWriterLE& outstream, int indent) {
-{
     std::ostringstream ss;
     ss.imbue(std::locale::classic());
     ss.precision(15); // this seems to match official FBX SDK exports
@@ -240,8 +263,7 @@ void FBX::Property::DumpAscii(Assimp::StreamWriterLE &outstream, int indent)
     outstream.PutString(ss.str());
 }
 
-void FBX::Property::DumpAscii(std::ostream& s, int indent)
+void FBXExportProperty::DumpAscii(std::ostream& s, int indent) {
-{
     // no writing type... or anything. just shove it into the stream.
     uint8_t* d = data.data();
     size_t N;
@@ -359,6 +381,9 @@ void FBX::Property::DumpAscii(std::ostream& s, int indent)
         throw runtime_error(err.str());
     }
 }
-}
+
+} // Namespace FBX
+} // Namespace Assimp
+
 #endif // ASSIMP_BUILD_NO_FBX_EXPORTER
 #endif // ASSIMP_BUILD_NO_EXPORT

code/FBXExportProperty.h

@@ -47,7 +47,6 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifndef ASSIMP_BUILD_NO_FBX_EXPORTER
 
-
 #include <assimp/types.h> // aiMatrix4x4
 #include <assimp/StreamWriter.h> // StreamWriterLE
 
@@ -58,10 +57,8 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 namespace Assimp {
 namespace FBX {
-    class Property;
-}
 
-/** FBX::Property
+/** @brief FBX::Property
  *
  *  Holds a value of any of FBX's recognized types,
  *  each represented by a particular one-character code.
@@ -79,35 +76,34 @@ namespace FBX {
  *  S : string (array of 1-byte char)
  *  R : raw data (array of bytes)
  */
-class FBX::Property
+class FBXExportProperty {
-{
 public:
     // constructors for basic types.
     // all explicit to avoid accidental typecasting
-    explicit Property(bool v);
+    explicit FBXExportProperty(bool v);
     // TODO: determine if there is actually a byte type,
     // or if this always means <bool>. 'C' seems to imply <char>,
     // so possibly the above was intended to represent both.
-    explicit Property(int16_t v);
+    explicit FBXExportProperty(int16_t v);
-    explicit Property(int32_t v);
+    explicit FBXExportProperty(int32_t v);
-    explicit Property(float v);
+    explicit FBXExportProperty(float v);
-    explicit Property(double v);
+    explicit FBXExportProperty(double v);
-    explicit Property(int64_t v);
+    explicit FBXExportProperty(int64_t v);
     // strings can either be stored as 'R' (raw) or 'S' (string) type
-    explicit Property(const char* c, bool raw=false);
+    explicit FBXExportProperty(const char* c, bool raw = false);
-    explicit Property(const std::string& s, bool raw=false);
+    explicit FBXExportProperty(const std::string& s, bool raw = false);
-    explicit Property(const std::vector<uint8_t>& r);
+    explicit FBXExportProperty(const std::vector<uint8_t>& r);
-    explicit Property(const std::vector<int32_t>& va);
+    explicit FBXExportProperty(const std::vector<int32_t>& va);
-    explicit Property(const std::vector<int64_t>& va);
+    explicit FBXExportProperty(const std::vector<int64_t>& va);
-    explicit Property(const std::vector<double>& va);
+    explicit FBXExportProperty(const std::vector<double>& va);
-    explicit Property(const std::vector<float>& va);
+    explicit FBXExportProperty(const std::vector<float>& va);
-    explicit Property(const aiMatrix4x4& vm);
+    explicit FBXExportProperty(const aiMatrix4x4& vm);
 
     // this will catch any type not defined above,
     // so that we don't accidentally convert something we don't want.
     // for example (const char*) --> (bool)... seriously wtf C++
     template <class T>
-    explicit Property(T v) : type('X') {
+    explicit FBXExportProperty(T v) : type('X') {
         static_assert(std::is_void<T>::value, "TRIED TO CREATE FBX PROPERTY WITH UNSUPPORTED TYPE, CHECK YOUR PROPERTY INSTANTIATION");
     } // note: no line wrap so it appears verbatim on the compiler error
 
@@ -115,16 +111,19 @@ public:
     size_t size();
 
     // write this property node as binary data to the given stream
-    void DumpBinary(Assimp::StreamWriterLE &s);
+    void DumpBinary(Assimp::StreamWriterLE& s);
-    void DumpAscii(Assimp::StreamWriterLE &s, int indent=0);
+    void DumpAscii(Assimp::StreamWriterLE& s, int indent = 0);
-    void DumpAscii(std::ostream &s, int indent=0);
+    void DumpAscii(std::ostream& s, int indent = 0);
     // note: make sure the ostream is in classic "C" locale
 
 private:
     char type;
     std::vector<uint8_t> data;
 };
-}
+
+} // Namespace FBX
+} // Namespace Assimp
+
 #endif // ASSIMP_BUILD_NO_FBX_EXPORTER
 
 #endif // AI_FBXEXPORTPROPERTY_H_INC

code/FBXExporter.cpp

@@ -2271,8 +2271,8 @@ void FBXExporter::WriteModelNode(
 
     // not sure what these are for,
     // but they seem to be omnipresent
-    m.AddChild("Shading", Property(true));
+    m.AddChild("Shading", FBXExportProperty(true));
-    m.AddChild("Culling", Property("CullingOff"));
+    m.AddChild("Culling", FBXExportProperty("CullingOff"));
 
     m.Dump(outstream, binary, 1);
 }
@@ -2385,7 +2385,7 @@ void FBXExporter::WriteModelNodes(
         na.AddProperties(
             node_attribute_uid, FBX::SEPARATOR + "NodeAttribute", "LimbNode"
         );
-        na.AddChild("TypeFlags", Property("Skeleton"));
+        na.AddChild("TypeFlags", FBXExportProperty("Skeleton"));
         na.Dump(outstream, binary, 1);
         // and connect them
         connections.emplace_back("C", "OO", node_attribute_uid, node_uid);

packaging/windows-innosetup/script_x64.iss

@@ -2,19 +2,19 @@
 
 [Setup]
 AppName=Open Asset Import Library - SDK
-AppVerName=Open Asset Import Library - SDK (v4.1.0)
+AppVerName=Open Asset Import Library - SDK (v5.0.0)
 DefaultDirName={pf}\Assimp
 DefaultGroupName=Assimp
-UninstallDisplayIcon={app}\bin\x86\assimp.exe
+UninstallDisplayIcon={app}\bin\x64\assimp.exe
 OutputDir=out
 AppCopyright=Assimp Development Team
 SetupIconFile=..\..\tools\shared\assimp_tools_icon.ico
 WizardImageFile=compiler:WizModernImage-IS.BMP
 WizardSmallImageFile=compiler:WizModernSmallImage-IS.BMP
 LicenseFile=License.rtf
-OutputBaseFileName=assimp-sdk-4.1.0-setup
+OutputBaseFileName=assimp-sdk-5.0.0-setup
-VersionInfoVersion=4.1.0.0
+VersionInfoVersion=5.0.0.0
-VersionInfoTextVersion=4.1.0
+VersionInfoTextVersion=5.0.0
 VersionInfoCompany=Assimp Development Team
 ArchitecturesInstallIn64BitMode=x64
 
@@ -32,7 +32,7 @@ Name: "test";        Description: "Test Models (BSD-licensed)"; Types: full
 Name: "test_nonbsd"; Description: "Test Models (other (free) licenses)"; Types: full
 
 [Run]
-Filename: "{app}\stub\vc_redist.x64.exe"; Parameters: "/qb"; StatusMsg: "Installing VS2017 redistributable package (64 Bit)"; Check: IsWin64
+Filename: "{app}\stub\vc_redist.x64.exe"; Parameters: "/qb /passive /quiet"; StatusMsg: "Installing VS2017 redistributable package (64 Bit)"; Check: IsWin64
 
 [Files]
 Source: "readme_installer.txt"; DestDir: "{app}"; Flags: isreadme
@@ -64,6 +64,9 @@ Source: "..\..\samples\*"; DestDir: "{app}\samples"; Flags: recursesubdirs; Comp
 ; Include files
 Source: "..\..\include\*"; DestDir: "{app}\include"; Flags: recursesubdirs
 
+; CMake files
+Source: "..\..\cmake-modules\*"; DestDir: "{app}\cmake-modules"; Flags: recursesubdirs
+
 [Icons]
 ; Name: "{group}\Assimp Manual"; Filename: "{app}\doc\AssimpDoc.chm" ; Components: help
 ; Name: "{group}\Assimp Command Line Manual"; Filename: "{app}\doc\AssimpCmdDoc.chm"; Components: help

packaging/windows-innosetup/script_x86.iss

@@ -2,7 +2,7 @@
 
 [Setup]
 AppName=Open Asset Import Library - SDK
-AppVerName=Open Asset Import Library - SDK (v4.1.0)
+AppVerName=Open Asset Import Library - SDK (v5.0.0)
 DefaultDirName={pf}\Assimp
 DefaultGroupName=Assimp
 UninstallDisplayIcon={app}\bin\x86\assimp.exe
@@ -12,11 +12,11 @@ SetupIconFile=..\..\tools\shared\assimp_tools_icon.ico
 WizardImageFile=compiler:WizModernImage-IS.BMP
 WizardSmallImageFile=compiler:WizModernSmallImage-IS.BMP
 LicenseFile=License.rtf
-OutputBaseFileName=assimp-sdk-4.1.0-setup
+OutputBaseFileName=assimp-sdk-5.0.0-setup
 VersionInfoVersion=4.1.0.0
 VersionInfoTextVersion=4.1.0
 VersionInfoCompany=Assimp Development Team
-ArchitecturesInstallIn64BitMode=x64
+;ArchitecturesInstallIn64BitMode=x64
 
 [Types]
 Name: "full";    Description: "Full installation"
@@ -32,7 +32,7 @@ Name: "test";        Description: "Test Models (BSD-licensed)"; Types: full
 Name: "test_nonbsd"; Description: "Test Models (other (free) licenses)"; Types: full
 
 [Run]
-Filename: "{app}\stub\vc_redist.x86.exe"; Parameters: "/qb"; StatusMsg: "Installing VS2017 redistributable package (32 Bit)"; Check: not IsWin64
+Filename: "{app}\stub\vc_redist.x86.exe"; Parameters: "/qb /passive /quiet"; StatusMsg: "Installing VS2017 redistributable package (32 Bit)"; Check: not IsWin64
 
 [Files]
 Source: "readme_installer.txt"; DestDir: "{app}"; Flags: isreadme
@@ -65,6 +65,9 @@ Source: "..\..\samples\*"; DestDir: "{app}\samples"; Flags: recursesubdirs; Comp
 ; Include files
 Source: "..\..\include\*"; DestDir: "{app}\include"; Flags: recursesubdirs
 
+; CMake files
+Source: "..\..\cmake-modules\*"; DestDir: "{app}\cmake-modules"; Flags: recursesubdirs
+
 [Icons]
 ; Name: "{group}\Assimp Manual"; Filename: "{app}\doc\AssimpDoc.chm" ; Components: help
 ; Name: "{group}\Assimp Command Line Manual"; Filename: "{app}\doc\AssimpCmdDoc.chm"; Components: help

test/models/PLY/cube_test.ply

@@ -1,6 +1,6 @@
 ply
 format ascii 1.0
-comment Created by Open Asset Import Library - http://assimp.sf.net (v4.1.412856994)
+comment Created by Open Asset Import Library - http://assimp.sf.net (v4.1.3297435427)
 element vertex 8
 property float x
 property float y