Merge branch 'master' into update-copyright-end-date

CMakeLists.txt

@@ -51,7 +51,7 @@ IF(HUNTER_ENABLED)
   add_definitions(-DASSIMP_USE_HUNTER)
 ENDIF(HUNTER_ENABLED)
 
-PROJECT( Assimp VERSION 5.0.0 )
+PROJECT( Assimp VERSION 5.0.1 )
 
 # All supported options ###############################################
 

code/Common/ScenePreprocessor.cpp

@@ -217,6 +217,7 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
 
                 // No rotation keys? Generate a dummy track
                 if (!channel->mNumRotationKeys) {
+                    ai_assert(!channel->mRotationKeys);
                     channel->mNumRotationKeys = 1;
                     channel->mRotationKeys = new aiQuatKey[1];
                     aiQuatKey& q = channel->mRotationKeys[0];
@@ -225,10 +226,13 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
                     q.mValue = rotation;
 
                     ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy rotation track has been generated");
+                } else {
+                    ai_assert(channel->mRotationKeys);
                 }
 
                 // No scaling keys? Generate a dummy track
                 if (!channel->mNumScalingKeys)  {
+                    ai_assert(!channel->mScalingKeys);
                     channel->mNumScalingKeys = 1;
                     channel->mScalingKeys = new aiVectorKey[1];
                     aiVectorKey& q = channel->mScalingKeys[0];
@@ -237,10 +241,13 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
                     q.mValue = scaling;
 
                     ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy scaling track has been generated");
+                } else {
+                    ai_assert(channel->mScalingKeys);
                 }
 
                 // No position keys? Generate a dummy track
                 if (!channel->mNumPositionKeys) {
+                    ai_assert(!channel->mPositionKeys);
                     channel->mNumPositionKeys = 1;
                     channel->mPositionKeys = new aiVectorKey[1];
                     aiVectorKey& q = channel->mPositionKeys[0];
@@ -249,6 +256,8 @@ void ScenePreprocessor::ProcessAnimation (aiAnimation* anim)
                     q.mValue = position;
 
                     ASSIMP_LOG_DEBUG("ScenePreprocessor: Dummy position track has been generated");
+                } else {
+                    ai_assert(channel->mPositionKeys);
                 }
             }
         }

code/X/XFileImporter.cpp

@@ -513,30 +513,36 @@ void XFileImporter::CreateAnimations( aiScene* pScene, const XFile::Scene* pData
             } else {
                 // separate key sequences for position, rotation, scaling
                 nbone->mNumPositionKeys = (unsigned int)bone->mPosKeys.size();
-                nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
-                for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) {
-                    aiVector3D pos = bone->mPosKeys[c].mValue;
+                if (nbone->mNumPositionKeys != 0) {
+                    nbone->mPositionKeys = new aiVectorKey[nbone->mNumPositionKeys];
+                    for( unsigned int c = 0; c < nbone->mNumPositionKeys; ++c ) {
+                        aiVector3D pos = bone->mPosKeys[c].mValue;
 
-                    nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
-                    nbone->mPositionKeys[c].mValue = pos;
+                        nbone->mPositionKeys[c].mTime = bone->mPosKeys[c].mTime;
+                        nbone->mPositionKeys[c].mValue = pos;
+                    }
                 }
 
                 // rotation
                 nbone->mNumRotationKeys = (unsigned int)bone->mRotKeys.size();
-                nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
-                for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) {
-                    aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
-
-                    nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
-                    nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat);
-                    nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
+                if (nbone->mNumRotationKeys != 0) {
+                    nbone->mRotationKeys = new aiQuatKey[nbone->mNumRotationKeys];
+                    for( unsigned int c = 0; c < nbone->mNumRotationKeys; ++c ) {
+                        aiMatrix3x3 rotmat = bone->mRotKeys[c].mValue.GetMatrix();
+
+                        nbone->mRotationKeys[c].mTime = bone->mRotKeys[c].mTime;
+                        nbone->mRotationKeys[c].mValue = aiQuaternion( rotmat);
+                        nbone->mRotationKeys[c].mValue.w *= -1.0f; // needs quat inversion
+                    }
                 }
 
                 // scaling
                 nbone->mNumScalingKeys = (unsigned int)bone->mScaleKeys.size();
-                nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
-                for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
-                    nbone->mScalingKeys[c] = bone->mScaleKeys[c];
+                if (nbone->mNumScalingKeys != 0) {
+                    nbone->mScalingKeys = new aiVectorKey[nbone->mNumScalingKeys];
+                    for( unsigned int c = 0; c < nbone->mNumScalingKeys; c++)
+                        nbone->mScalingKeys[c] = bone->mScaleKeys[c];
+                }
 
                 // longest lasting key sequence determines duration
                 if( bone->mPosKeys.size() > 0)

test/CMakeLists.txt

@@ -129,6 +129,7 @@ SET( IMPORTERS
   unit/ImportExport/utNFFImportExport.cpp
   unit/ImportExport/utXGLImportExport.cpp
   unit/ImportExport/utMD2Importer.cpp
+  unit/ImportExport/utMD3Importer.cpp
   unit/ImportExport/utMD5Importer.cpp
   unit/ImportExport/utMDLImporter.cpp
   unit/ImportExport/MDL/MDLHL1TestFiles.h

test/unit/ImportExport/utMD3Importer.cpp

@@ -0,0 +1,73 @@
+/*
+---------------------------------------------------------------------------
+Open Asset Import Library (assimp)
+---------------------------------------------------------------------------
+
+Copyright (c) 2006-2020, assimp team
+
+
+
+All rights reserved.
+
+Redistribution and use of this software in source and binary forms,
+with or without modification, are permitted provided that the following
+conditions are met:
+
+* Redistributions of source code must retain the above
+copyright notice, this list of conditions and the
+following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the
+following disclaimer in the documentation and/or other
+materials provided with the distribution.
+
+* Neither the name of the assimp team, nor the names of its
+contributors may be used to endorse or promote products
+derived from this software without specific prior
+written permission of the assimp team.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+---------------------------------------------------------------------------
+*/
+
+#include "UnitTestPCH.h"
+
+#include <assimp/postprocess.h>
+#include <assimp/scene.h>
+#include <assimp/Importer.hpp>
+
+
+using namespace Assimp;
+
+
+
+TEST(utMD3Importer, importWatercan) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_NONBSD_DIR "/MD3/watercan.md3", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utMD3Importer, importWatercan_dmg) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_NONBSD_DIR "/MD3/watercan_dmg.md3", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utMD3Importer, importEuropean_fnt_v2) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_NONBSD_DIR "/MD3/q3root/models/mapobjects/kt_kubalwagon/european_fnt_v2.md3", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}

test/unit/ImportExport/utXGLImportExport.cpp

@@ -42,22 +42,64 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "UnitTestPCH.h"
-#include "AbstractImportExportBase.h"
 #include <assimp/Importer.hpp>
 #include <assimp/postprocess.h>
 
+
 using namespace Assimp;
 
-class utXGLImportExport : public AbstractImportExportBase {
-public:
-    virtual bool importerTest() {
-        Assimp::Importer importer;
-        const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/sample_official.xgl", 0);
-        return true;
-        return nullptr != scene;
-    }
-};
-
-TEST_F(utXGLImportExport, importXGLFromFileTest) {
-    EXPECT_TRUE(importerTest());
+
+TEST(utXGLImporter, importBCN_Epileptic) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/BCN_Epileptic.zgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importCubesWithAlpha) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/cubes_with_alpha.zgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importSample_official) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/sample_official.xgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importSample_official_asxml) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/sample_official_asxml.xml", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importSphereWithMatGloss) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/sphere_with_mat_gloss_10pc.zgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importSpiderASCII) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/Spider_ascii.zgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importWuson) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/Wuson.zgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXGLImporter, importWusonDXF) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/XGL/wuson_dxf.zgl", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
 }

test/unit/ut3DImportExport.cpp

@@ -42,23 +42,30 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "UnitTestPCH.h"
-#include "SceneDiffer.h"
-#include "AbstractImportExportBase.h"
 
 #include <assimp/Importer.hpp>
 #include <assimp/postprocess.h>
 
+
 using namespace Assimp;
 
-class ut3DImportExport : public AbstractImportExportBase {
-public:
-    virtual bool importerTest() {
-        Assimp::Importer importer;
-        const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/3D/box_a.3d", aiProcess_ValidateDataStructure );
-        return nullptr != scene;
-    }
-};
-
-TEST_F( ut3DImportExport, import3DFromFileTest ) {
-    EXPECT_TRUE( importerTest() );
+
+TEST(ut3DImportExport, importBoxA) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/3D/box_a.3d", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(ut3DImportExport, importBoxD) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/3D/box_d.3d", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(ut3DImportExport, importBoxUC) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/3D/box.uc", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
 }

test/unit/utACImportExport.cpp

@@ -42,23 +42,81 @@ OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
 
 #include "UnitTestPCH.h"
-#include "SceneDiffer.h"
-#include "AbstractImportExportBase.h"
 
 #include <assimp/Importer.hpp>
 #include <assimp/postprocess.h>
 
+
 using namespace Assimp;
 
-class utACImportExport : public AbstractImportExportBase {
-public:
-    virtual bool importerTest() {
-        Assimp::Importer importer;
-        const aiScene *scene = importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/AC/Wuson.ac", aiProcess_ValidateDataStructure );
-        return nullptr != scene;
-    }
-};
-
-TEST_F( utACImportExport, importACFromFileTest ) {
-    EXPECT_TRUE( importerTest() );
+
+TEST(utACImportExport, importClosedLine) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/closedLine.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importNoSurfaces) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/nosurfaces.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importOpenLine) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/openLine.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importSampleSubdiv) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/sample_subdiv.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importSphereWithLight) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/SphereWithLight.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importSphereWithLightUTF16) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/SphereWithLight_UTF16LE.ac", aiProcess_ValidateDataStructure);
+    // FIXME: this is probably wrong, loading the file should succeed
+    ASSERT_EQ(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importSphereWithLightUTF8BOM) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/SphereWithLight_UTF8BOM.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, importSphereWithLightUvScaling4X) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/SphereWithLightUvScaling4X.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
 }
+
+
+TEST(utACImportExport, importWuson) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/Wuson.ac", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utACImportExport, testFormatDetection) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/AC/TestFormatDetection", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+

test/unit/utXImporterExporter.cpp

@@ -67,3 +67,73 @@ TEST_F( utXImporterExporter, heap_overflow_in_tokenizer ) {
     Assimp::Importer importer;
     EXPECT_NO_THROW( importer.ReadFile( ASSIMP_TEST_MODELS_DIR "/X/OV_GetNextToken", 0 ) );
 }
+
+
+TEST(utXImporter, importAnimTest) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/anim_test.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importBCNEpileptic) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/BCN_Epileptic.X", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importFromTrueSpaceBin32) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/fromtruespace_bin32.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, import_kwxport_test_cubewithvcolors) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/kwxport_test_cubewithvcolors.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importTestCubeBinary) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/test_cube_binary.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importTestCubeCompressed) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/test_cube_compressed.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importTestCubeText) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/test_cube_text.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importTestWuson) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/Testwuson.X", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, TestFormatDetection) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_DIR "/X/TestFormatDetection", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}
+
+
+TEST(utXImporter, importDwarf) {
+    Assimp::Importer importer;
+    const aiScene *scene = importer.ReadFile(ASSIMP_TEST_MODELS_NONBSD_DIR "/X/dwarf.x", aiProcess_ValidateDataStructure);
+    ASSERT_NE(nullptr, scene);
+}