From 058f98a63658dc1a2579826ba167fd61bed1e21f Mon Sep 17 00:00:00 2001 From: sanine Date: Fri, 4 Mar 2022 10:47:15 -0600 Subject: add assimp submodule --- src/mesh/assimp-master/test/unit/SceneDiffer.cpp | 374 +++++++++++++++++++++++ 1 file changed, 374 insertions(+) create mode 100644 src/mesh/assimp-master/test/unit/SceneDiffer.cpp (limited to 'src/mesh/assimp-master/test/unit/SceneDiffer.cpp') diff --git a/src/mesh/assimp-master/test/unit/SceneDiffer.cpp b/src/mesh/assimp-master/test/unit/SceneDiffer.cpp new file mode 100644 index 0000000..0918530 --- /dev/null +++ b/src/mesh/assimp-master/test/unit/SceneDiffer.cpp @@ -0,0 +1,374 @@ +/* +--------------------------------------------------------------------------- +Open Asset Import Library (assimp) +--------------------------------------------------------------------------- + +Copyright (c) 2006-2022, 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 "SceneDiffer.h" +#include +#include +#include +#include + +namespace Assimp { + +SceneDiffer::SceneDiffer() +: m_diffs() { + // empty +} + +SceneDiffer::~SceneDiffer() { + // empty +} + +bool SceneDiffer::isEqual( const aiScene *expected, const aiScene *toCompare ) { + if ( expected == toCompare ) { + return true; + } + + if ( nullptr == expected ) { + return false; + } + + if ( nullptr == toCompare ) { + return false; + } + + // meshes + if ( expected->mNumMeshes != toCompare->mNumMeshes ) { + std::stringstream stream; + stream << "Number of meshes not equal ( expected: " << expected->mNumMeshes << ", found : " << toCompare->mNumMeshes << " )\n"; + addDiff( stream.str() ); + return false; + } + + for ( unsigned int i = 0; i < expected->mNumMeshes; i++ ) { + aiMesh *expMesh( expected->mMeshes[ i ] ); + aiMesh *toCompMesh( toCompare->mMeshes[ i ] ); + if ( !compareMesh( expMesh, toCompMesh ) ) { + std::stringstream stream; + stream << "Meshes are not equal, index : " << i << "\n"; + addDiff( stream.str() ); + } + } + + // materials + /*if ( expected->mNumMaterials != toCompare->mNumMaterials ) { + std::stringstream stream; + stream << "Number of materials not equal ( expected: " << expected->mNumMaterials << ", found : " << toCompare->mNumMaterials << " )\n"; + addDiff( stream.str() ); + return false; + } + + if ( expected->mNumMaterials > 0 ) { + if ( nullptr == expected->mMaterials || nullptr == toCompare->mMaterials ) { + addDiff( "Number of materials > 0 and mat pointer is nullptr" ); + return false; + } + } + + for ( unsigned int i = 0; i < expected->mNumMaterials; i++ ) { + aiMaterial *expectedMat( expected->mMaterials[ i ] ); + aiMaterial *toCompareMat( expected->mMaterials[ i ] ); + if ( !compareMaterial( expectedMat, toCompareMat ) ) { + std::stringstream stream; + stream << "Materials are not equal, index : " << i << "\n"; + addDiff( stream.str() ); + return false; + } + }*/ + + return true; +} + +void SceneDiffer::showReport() { + if ( m_diffs.empty() ) { + return; + } + + for ( std::vector::iterator it = m_diffs.begin(); it != m_diffs.end(); ++it ) { + std::cout << *it << "\n"; + } + + std::cout << std::endl; +} + +void SceneDiffer::reset() { + m_diffs.resize( 0 ); +} + +void SceneDiffer::addDiff( const std::string &diff ) { + if ( diff.empty() ) { + return; + } + m_diffs.push_back( diff ); +} + +static std::string dumpVector3( const aiVector3D &toDump ) { + std::stringstream stream; + stream << "( " << toDump.x << ", " << toDump.y << ", " << toDump.z << ")"; + return stream.str(); +} + +/*static std::string dumpColor4D( const aiColor4D &toDump ) { + std::stringstream stream; + stream << "( " << toDump.r << ", " << toDump.g << ", " << toDump.b << ", " << toDump.a << ")"; + return stream.str(); +}*/ + +static std::string dumpFace( const aiFace &face ) { + std::stringstream stream; + for ( unsigned int i = 0; i < face.mNumIndices; i++ ) { + stream << face.mIndices[ i ]; + if ( i < face.mNumIndices - 1 ) { + stream << ", "; + } + else { + stream << "\n"; + } + } + return stream.str(); +} + +bool SceneDiffer::compareMesh( aiMesh *expected, aiMesh *toCompare ) { + if ( expected == toCompare ) { + return true; + } + + if ( nullptr == expected || nullptr == toCompare ) { + return false; + } + + if ( expected->mName != toCompare->mName ) { + std::stringstream stream; + stream << "Mesh name not equal ( expected: " << expected->mName.C_Str() << ", found : " << toCompare->mName.C_Str() << " )\n"; + addDiff( stream.str() ); + } + + if ( expected->mNumVertices != toCompare->mNumVertices ) { + std::stringstream stream; + stream << "Number of vertices not equal ( expected: " << expected->mNumVertices << ", found : " << toCompare->mNumVertices << " )\n"; + addDiff( stream.str() ); + return false; + } + + // positions + if ( expected->HasPositions() != toCompare->HasPositions() ) { + addDiff( "Expected are vertices, toCompare does not have any." ); + return false; + } + + bool vertEqual( true ); + for ( unsigned int i = 0; i < expected->mNumVertices; i++ ) { + aiVector3D &expVert( expected->mVertices[ i ] ); + aiVector3D &toCompVert( toCompare->mVertices[ i ] ); + if ( !expVert.Equal( toCompVert ) ) { + std::cout << "index = " << i << dumpVector3( toCompVert ) << "\n"; + std::stringstream stream; + stream << "Vertex not equal ( expected: " << dumpVector3( toCompVert ) << ", found: " << dumpVector3( toCompVert ) << "\n"; + addDiff( stream.str() ); + vertEqual = false; + } + } + if ( !vertEqual ) { + return false; + } + + // normals + if ( expected->HasNormals() != toCompare->HasNormals() ) { + addDiff( "Expected are normals, toCompare does not have any." ); + return false; + } + + // return true; + + //ToDo! + /*bool normalEqual( true ); + for ( unsigned int i = 0; i < expected->mNumVertices; i++ ) { + aiVector3D &expNormal( expected->mNormals[ i ] ); + aiVector3D &toCompNormal( toCompare->mNormals[ i ] ); + if ( expNormal.Equal( toCompNormal ) ) { + std::stringstream stream; + stream << "Normal not equal ( expected: " << dumpVector3( expNormal ) << ", found: " << dumpVector3( toCompNormal ) << "\n"; + addDiff( stream.str() ); + normalEqual = false; + } + } + if ( !normalEqual ) { + return false; + } + + // vertex colors + bool vertColEqual( true ); + for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_COLOR_SETS; a++ ) { + if ( expected->HasVertexColors(a) != toCompare->HasVertexColors(a) ) { + addDiff( "Expected are normals, toCompare does not have any." ); + return false; + } + for ( unsigned int i = 0; i < expected->mNumVertices; i++ ) { + aiColor4D &expColor4D( expected->mColors[ a ][ i ] ); + aiColor4D &toCompColor4D( toCompare->mColors[ a ][ i ] ); + if ( expColor4D != toCompColor4D ) { + std::stringstream stream; + stream << "Color4D not equal ( expected: " << dumpColor4D( expColor4D ) << ", found: " << dumpColor4D( toCompColor4D ) << "\n"; + addDiff( stream.str() ); + vertColEqual = false; + } + } + if ( !vertColEqual ) { + return false; + } + } + + // texture coords + bool texCoordsEqual( true ); + for ( unsigned int a = 0; a < AI_MAX_NUMBER_OF_TEXTURECOORDS; a++ ) { + if ( expected->HasTextureCoords( a ) != toCompare->HasTextureCoords( a ) ) { + addDiff( "Expected are texture coords, toCompare does not have any." ); + return false; + } + for ( unsigned int i = 0; i < expected->mNumVertices; i++ ) { + aiVector3D &expTexCoord( expected->mTextureCoords[ a ][ i ] ); + aiVector3D &toCompTexCoord( toCompare->mTextureCoords[ a ][ i ] ); + if ( expTexCoord.Equal( toCompTexCoord ) ) { + std::stringstream stream; + stream << "Texture coords not equal ( expected: " << dumpVector3( expTexCoord ) << ", found: " << dumpVector3( toCompTexCoord ) << "\n"; + addDiff( stream.str() ); + vertColEqual = false; + } + } + if ( !vertColEqual ) { + return false; + } + } + + // tangents and bi-tangents + if ( expected->HasTangentsAndBitangents() != toCompare->HasTangentsAndBitangents() ) { + addDiff( "Expected are tangents and bi-tangents, toCompare does not have any." ); + return false; + } + bool tangentsEqual( true ); + for ( unsigned int i = 0; i < expected->mNumVertices; i++ ) { + aiVector3D &expTangents( expected->mTangents[ i ] ); + aiVector3D &toCompTangents( toCompare->mTangents[ i ] ); + if ( expTangents.Equal( toCompTangents ) ) { + std::stringstream stream; + stream << "Tangents not equal ( expected: " << dumpVector3( expTangents ) << ", found: " << dumpVector3( toCompTangents ) << "\n"; + addDiff( stream.str() ); + tangentsEqual = false; + } + + aiVector3D &expBiTangents( expected->mBitangents[ i ] ); + aiVector3D &toCompBiTangents( toCompare->mBitangents[ i ] ); + if ( expBiTangents.Equal( toCompBiTangents ) ) { + std::stringstream stream; + stream << "Tangents not equal ( expected: " << dumpVector3( expBiTangents ) << ", found: " << dumpVector3( toCompBiTangents ) << " )\n"; + addDiff( stream.str() ); + tangentsEqual = false; + } + } + if ( !tangentsEqual ) { + return false; + }*/ + + // faces + if ( expected->mNumFaces != toCompare->mNumFaces ) { + std::stringstream stream; + stream << "Number of faces are not equal, ( expected: " << expected->mNumFaces << ", found: " << toCompare->mNumFaces << ")\n"; + addDiff( stream.str() ); + return false; + } + bool facesEqual( true ); + for ( unsigned int i = 0; i < expected->mNumFaces; i++ ) { + aiFace &expFace( expected->mFaces[ i ] ); + aiFace &toCompareFace( toCompare->mFaces[ i ] ); + if ( !compareFace( &expFace, &toCompareFace ) ) { + addDiff( "Faces are not equal\n" ); + addDiff( dumpFace( expFace ) ); + addDiff( dumpFace( toCompareFace ) ); + facesEqual = false; + } + } + if ( !facesEqual ) { + return false; + } + + return true; +} + +bool SceneDiffer::compareFace( aiFace *expected, aiFace *toCompare ) { + if ( nullptr == expected ) { + return false; + } + if ( nullptr == toCompare ) { + return false; + } + + // same instance + if ( expected == toCompare ) { + return true; + } + + // using compare operator + if ( *expected == *toCompare ) { + return true; + } + + return false; +} + +bool SceneDiffer::compareMaterial( aiMaterial *expected, aiMaterial *toCompare ) { + if ( nullptr == expected ) { + return false; + } + if ( nullptr == toCompare ) { + return false; + } + + // same instance + if ( expected == toCompare ) { + return true; + } + + // todo! + + return true; +} + +} -- cgit v1.2.1